java中的内部类

Ⅰ 在java中什么是内部类

内部类就是写在类中或方法中的类，它还是一个类，与其他类的不同就是他只为这个外部类（包含内部类的类）类所用

Ⅱ java里面的内部类和外部类是什么_

外部类：
最普通的，我们平时见到的那种类，就是在一个后缀为.java的文件中，直接定义的类
内部类：
内部类，顾名思义，就是包含在外部类中的类，就叫做内部类。内部类有两种，一种是静态内部类，一种是非静态内部类。
静态内部类和非静态内部类之间的区别主要如下：
1、内部原理的区别：
静态内部类是属于外部类的类成员，是一种静态的成员，是属于类的，就有点类似于private static Singleton instance = null；非静态内部类，是属于外部类的实例对象的一个实例成员,静态类则是属于所有外部共有的，也就是说，每个非静态内部类，不是属于外部类的，是属于外部类的每一个实例的，创建非静态内部类的实例以后，非静态内部类实例，是必须跟一个外部类的实例进行关联和有寄存关系的。
2、创建方式的区别：
创建静态内部类的实例的时候，只要直接使用“外部类.内部类()”的方式，就可以，比如School.Teacher()；创建非静态内部类的实例的时候，必须要先创建一个外部类的实例，然后通过外部类的实例，再来创建内部类的实例，new School().Teacher()
通常来说，我们一般都会为了方便，会选择使用静态内部类。

Ⅲ Java内部类有几种

Java中的几种内部类：
成员内部类：作为外部类的一个成员存在，与外部类的属性、方法并列。当某个类除了他的外部类，不会被其他类使用时应该选择使用成员内部类。
局部内部类：局部内部类定义在外部类的某个代码块或方法块中。如果只会在某个方法或块中创建这个类的对象，就可以使用局部内部类。
匿名内部类：匿名内部类一般定义在需要传递接口或回调的的地方，一个匿名内部类一定是在new的后面，用其隐含实现一个接口或继承一个类。假如只需要创建这个类的一个对象不需要知道其实际类型(不需要使用到类名)，那么就可以使用匿名内部类。
静态内部类：和成员内部类一样，作为外部类的一个成员存在，与外部类的属性、方法并列，只不过在声明类的时候加入了static关键字。有时候，使用内部类只是为了把一个类隐藏在另外一个类的内部，并不需要内部类引用外围类对象。这时可以使用静态内部类，以便取消产生对外部类的引用。

Ⅳ Java 静态内部类作用

1、变值权限修饰作用，在定义内部类的时候，可以在其前面加上一个权限修饰符static。此时这个内部类就变为了静态内部类。

2、在某些特殊的情况下，少了这个静态内部类还真是不行。如在进行代码程序测试的时候，如果在每一个Java源文件中都设置一个主方法(主方法是某个应用程序的入口，必须具有)，那么会出现很多额外的代码。

3、最主要的时这段主程序的代码对于Java文件来说，只是一个形式，其本身并不需要这种主方法。但是少了这个主方法又是万万不行的。在这种情况下，就可以将主方法写入到静态内部类中，从而不用为每个Java源文件都设置一个类似的主方法。

这对于代码测试是非常有用的。在一些中大型的应用程序开发中，则是一个常用的技术手段。

(4)java中的内部类扩展阅读

例如：

对于两个类，拥有相同的方法：

class People{

run();

}

interface Machine{

run();

}

此时有一个robot类：

class Robot extends People implement Machine.

此时run()不可直接实现。

interface Machine{

void run();

}

class Person{

void run(){

System.out.println("run");

}

}

class Robot extends Person{

private class MachineHeart implements Machine{

public void run(){

System.out.println("heart run");

}

}

public void run(){

System.out.println("Robot run");

}

Machine.getMachine(){returnnew MachineHeart();

}

class Test{

publicstaticvoid main(String[] args){

Robot robot=new Robot();

Machine m=robot.getMachine();

m.run();

robot.run();

}

}

Ⅳ java中内部类该何时用，怎么用

1.在一个类内部还存在另一个类，则后者为内部类；
2.内部类可声明成public或private，当内部类声明成public或private时，对其访问的限制与成员变量和成员方法完全相同；
3.定义格式：
标识符 class 外部类的名称{
//外部类的成员
标识符 class 内部类的名称{
//内部类的成员
}
}
示例：
class Outer{ // 定义外部类
private String info = "hello world" ; // 定义外部类的私有属性
class Inner{ // 定义内部类
public void print(){ // 定义内部类的方法
System.out.println(info) ; // 直接访问外部类的私有属性
}
};
public void fun(){ // 定义外部类的方法
new Inner().print() ; // 通过内部类的实例化对象调用方法
}
};
public class InnerClassDemo01{
public static void main(String args[]){
new Outer().fun() ; // 调用外部类的fun()方法
}
};
这位童鞋可以试着不用内部类写个程序完成以上功能，你会发现代码明显比之前的更加麻烦和复杂，所以内部类的唯一好处是方便的访问外部类中的私有属性，从而减少代码。

Ⅵ Java里什么叫内部类什么叫外部类

对普通类（没有内部类的类）来说，内部类和外部类都与他无关；对有内部类的类来说，它们就是其内部类的外部类，外部类是个相对的说法，其实就是有内部类的类。
所以，要回答这个问题，只需要讲解内部类是什么：
Java中的内部类共分为四种：
静态内部类static inner class (also called nested class)
成员内部类member inner class
局部内部类local inner class
匿名内部类anonymous inner class

静态内部类Static Inner Class
最简单的内部类形式。
类定义时加上static关键字。
不能和外部类有相同的名字。
被编译成一个完全独立的.class文件，名称为OuterClass$InnerClass.class的形式。
只可以访问外部类的静态成员和静态方法，包括了私有的静态成员和方法。
生成静态内部类对象的方式为：
OuterClass.InnerClass inner = new OuterClass.InnerClass();
示例代码：
package com.learnjava.innerclass;
class StaticInner
{
private static int a = 4;
// 静态内部类
public static class Inner
{
public void test()
{
// 静态内部类可以访问外部类的静态成员
// 并且它只能访问静态的
System.out.println(a);
}
}
}
public class StaticInnerClassTest
{
public static void main(String[] args)
{
StaticInner.Inner inner = new StaticInner.Inner();
inner.test();
}
}

成员内部类Member Inner Class
成员内部类也是定义在另一个类中，但是定义时不用static修饰。
成员内部类和静态内部类可以类比为非静态的成员变量和静态的成员变量。
成员内部类就像一个实例变量。
它可以访问它的外部类的所有成员变量和方法，不管是静态的还是非静态的都可以。
在外部类里面创建成员内部类的实例：
this.new Innerclass();
在外部类之外创建内部类的实例：
(new Outerclass()).new Innerclass();
在内部类里访问外部类的成员：
Outerclass.this.member
示例代码：
package com.learnjava.innerclass;
class MemberInner
{
private int d = 1;
private int a = 2;
// 定义一个成员内部类
public class Inner2
{
private int a = 8;
public void doSomething()
{
// 直接访问外部类对象
System.out.println(d);
System.out.println(a);// 直接访问a，则访问的是内部类里的a
// 如何访问到外部类里的a呢？
System.out.println(MemberInner.this.a);
}
}
}
public class MemberInnerClassTest
{
public static void main(String[] args)
{
// 创建成员内部类的对象
// 需要先创建外部类的实例
MemberInner.Inner2 inner = new MemberInner().new Inner2();
inner.doSomething();
}
}

局部内部类Local Inner Class
局部内部类定义在方法中，比方法的范围还小。是内部类中最少用到的一种类型。
像局部变量一样，不能被public, protected, private和static修饰。
只能访问方法中定义的final类型的局部变量。
局部内部类在方法中定义，所以只能在方法中使用，即只能在方法当中生成局部内部类的实例并且调用其方法。
示例代码：
package com.learnjava.innerclass;
class LocalInner
{
int a = 1;
public void doSomething()
{
int b = 2;
final int c = 3;
// 定义一个局部内部类
class Inner3
{
public void test()
{
System.out.println("Hello World");
System.out.println(a);
// 不可以访问非final的局部变量
// error: Cannot refer to a non-final variable b inside an inner
// class defined in a different method
// System.out.println(b);
// 可以访问final变量
System.out.println(c);
}
}
// 创建局部内部类的实例并调用方法
new Inner3().test();
}
}
public class LocalInnerClassTest
{
public static void main(String[] args)
{
// 创建外部类对象
LocalInner inner = new LocalInner();
// 调用外部类的方法
inner.doSomething();
}

}

匿名内部类Anonymous Inner Class
匿名内部类就是没有名字的局部内部类，不使用关键字class, extends, implements, 没有构造方法。
匿名内部类隐式地继承了一个父类或者实现了一个接口。
匿名内部类使用得比较多，通常是作为一个方法参数。
生成的.class文件中，匿名类会生成OuterClass$1.class文件，数字根据是第几个匿名类而类推。
示例代码：
package com.learnjava.innerclass;
import java.util.Date;
public class AnonymouseInnerClass
{
@SuppressWarnings("deprecation")
public String getDate(Date date)
{
return date.toLocaleString();
}
public static void main(String[] args)
{
AnonymouseInnerClass test = new AnonymouseInnerClass();
// 打印日期：
String str = test.getDate(new Date());
System.out.println(str);
System.out.println("----------------");
// 使用匿名内部类
String str2 = test.getDate(new Date()
{
});// 使用了花括号，但是不填入内容，执行结果和上面的完全一致
// 生成了一个继承了Date类的子类的对象
System.out.println(str2);
System.out.println("----------------");
// 使用匿名内部类，并且重写父类中的方法
String str3 = test.getDate(new Date()
{
// 重写父类中的方法
@Override
@Deprecated
public String toLocaleString()
{
return "Hello: " + super.toLocaleString();
}
});
System.out.println(str3);
}
}

Ⅶ java 中什么是内部类啊麻烦给讲解一下。谢谢！

楼上真牛...贴这么多...

简单的说,内部类就是类中的类,举个例子:

class A {
private int i;
private void m() {

}
class B {
mm(int j) {
i = j;
m();
}
}
}

这里,B就是A的内部类
内部类的特点就是,可以方便的访问外部类里面的私有方法和属性,比如,这里B里面可以直接访问A里面的私有属性i,和私有方法m()

Ⅷ java中内部类

在java语言中，有一种类叫做内部类(inner class)，也称为嵌入类(nested class)，它是定义在其他类的内部。内部类作为其外部类的一个成员，与其他成员一样，可以直接访问其外部类的数据和方法。只不过相比较外部类只有public和默认的修饰符不同，内部类作为一个成员，可以被任意修饰符修饰。编译器在编译时，内部类的名称为OuterClass$InnerClass.class 。

1、内部类访问数据变量
当在某些时候，内部类中定义的变量与外部类中变量名称相同时，如何确保正确地访问每一个变量呢？

1.1在main中直接从外部类调用内部类的方法

class Outer
{
private int index = 10;
class Inner
{
private int index = 20;
void print()
{
int index = 30;
System.out.println(this); // the object created from the Inner
System.out.println(Outer.this); // the object created from the Outer
System.out.println(index); // output is 30
System.out.println(this.index); // output is 20
System.out.println(Outer.this.index); // output is 10
}
}

void print()
{
Inner inner = new Inner();//得到内部类的引用
inner.print();
}
}

class Test
{
public static void main(String[] args)
{
Outer outer = new Outer();
outer.print();
}
}
在这里内部类Inner中关键字this指向内部类Inner的对象，如果要想指向外部类的对象，必须在this指针前加上外部类名称，表示this是指向外部类构造的碎屑，如Outer.this 。

1.2在main中显式返回内部类引用

class Outer
{
private int index = 10;
class Inner
{
private int index = 20;
void print()
{
int index = 30;
System.out.println(index);
System.out.println(this.index);
System.out.println(Outer.this.index);
}
}

Inner getInner()
{
return new Inner();//返回一个内部类的引用
}
}

class Test
{
public static void main(String[] args)
{
Outer outer = new Outer();
Outer.Inner inner = outer.getInner();
inner.print();
}
}
Inner是Outer的内部类，所以在类Test中必须用属性引用符来标识出内部类。

1.3当main方法在Outer类内部

class Outer
{
private int index = 10;
class Inner
{
private int index = 20;
void print()
{
int index = 30;
System.out.println(index);
System.out.println(this.index);
System.out.println(Outer.this.index);
}
}

Inner getInner()
{
return new Inner();//返回一个内部类的引用
}

public static void main(String[] args)
{
Outer outer = new Outer();
Inner inner = outer.getInner(); // 注意此处变化
inner.print();
}
}
因为main方法在Outer内部，故可以直接引用，不需要属性引用符。

1.4在main方法中直接产生内部类对象

class Test
{
public static void main(String[] args)
{
Outer outer = new Outer();
Outer.Inner inner = outer.new Inner(); // 注意此处变化
inner.print();
}
}
在利用new构造方法构造一个外部类对象时，并没有连带着构造一个内部类对象，故需要访问内部类方法时，必须使用new操作符为这个外部类对象再构造一个内部类对象。

2、局部内部类
在方法中定义的内部类是局部内部类，它只能访问方法中的final类型的局部变量，因为用final定义的局部变量相当于是一个常量，延长了其生命周期，使得方法在消亡时，其内部类仍可以访问该变量。另外，它同样也可以引用定义在外部类的变量和方法。而且方法体中的局部内部类不允许有访问修饰符。

class Outer
{
int num=10;
public void print(final int aArgs)
{
class Inner
{
int num=20;
public Inner()
{
System.out.println("This is Inner.");//此句可看出它与匿名内部类用法的不同。
}

public void print()
{
int num=30;
System.out.println(this); // the object created from the local Inner
System.out.println(num);
System.out.println(this.num);
System.out.println(Outer.this.num);
System.out.println(aArgs);
}
}
Inner inner=new Inner();//此句必须放在定义类Inner的后面
inner.print();
}

public static void main(String[] args)
{
Outer outer=new Outer();
outer.print(40);
}
}
对于局部类的命名，不管是在一个方法中定义多个类还是在几个方法中分别定义类，其编译后命名是：OuterClass$1InnerClass.class

3、匿名内部类
匿名内部类作为一种特殊的内部类，除了具有普通内部类的特点，还有自己的一些独有特性：
匿名内部类必须扩展一个基类或实现一个接口，但是不能有显式的extends和implements子句；
匿名内部类必须实现父类以及接口中的所有抽象方法；
匿名内部类总是使用父类的无参构造方法来创建实例。如果是实现了一个接口，则其构造方法是Object()；
匿名内部类编译后的命名为：OuterClass$n.class，其中n是一个从1开始的整数，如果在一个类中定义了多个匿名内部类，则按照他们的出现顺序从1开始排号。

abstract class A
{
abstract public void sayHello();
}

class Outer
{
public static void main(String[] args)
{
new Outer().callInner(new A()
{
public void sayHello()
{
System.out.println(this); // the object created from the anonymous Inner
System.out.println("Hello!");
}
});
}

public void callInner(A a)
{
a.sayHello();
}
}

4、静态内部类
和非静态内部类相比，区别就在于静态内部类没有了指向外部类的引用。除此之外，在任何非静态内部类中，都不能有静态数据，静态方法或者又一个静态内部类（内部类的嵌套可以不止一层）。不过静态内部类中却可以拥有这一切。这也算是两者的第二个区别吧。一个静态的内部类,才可以声明一个static成员，静态内部类可以访问外围类的静态方法、成员（包括private static的成员）。静态内部类实例化的时候不必先实例化外围类，可以直接实例化内部类。而对于非静态内部类则必须先实例化其外部类，才能再实例化本身。

5．内部类的继承
当一个类继承自一个内部类时，缺省的构造器不可用。必须使用如下语法：
class WithInner
{
class Inner
{
public void sayHello()
{
System.out.println("Hello.");
}
}
}

public class Test extends WithInner.Inner
{
Test(WithInner wi)
{
wi.super();
}
public static void main(String[] args)
{
WithInner wi=new WithInner();
Test test=new Test(wi);
test.sayHello();
}
}
因为每一个内部类都有一个指向外部类的引用，在继承一个内部类，必须先创建一个外部类，通过这个外部类引用来调用其内部类的构造方法。如果继承的内部类是一个静态内部类，则就不需要这样，直接super()调用即可；

6、内部类的2种特殊用法
一个类从另一个类派生出来，又要实现一个接口。但在接口中定义的方法与父类中定义的方法的意义不同，则可以利用内部类来解决这个问题。
interface Machine
{
void run();
}

class Person
{
void run()
{
System.out.println("run");
}
}

class Robot extends Person
{
private class MachineHeart implements Machine
{
public void run()
{
System.out.println("heart run");
}
}

Machine getMachine()
{
return new MachineHeart();
}
}

class Test
{
public static void main(String[] args)
{
Robot robot = new Robot();
Machine m = robot.getMachine();
m.run();
robot.run();
}
}
在Robot类内部使用内部类MachineHeart来实现接口Machine的run方法。同时Robot类又继承了父类Person的run方法。如果不使用内部类MachineHeart而使Robot直接实现接口Machine，则该如何调用父类的run方法？

利用内部类可解决c++中多重继承所解决的问题
class A
{
void fn1()
{
System.out.println("It' s fn1.");
}
}

abstract class B
{
abstract void fn2();
}

class C extends A
{
B getB()
{
return new B()
{
public void fn2()
{
System.out.println("It' s fn2.");
}
};
}
}

class Test
{
public static void main(String[] args)
{
C c = new C();
c.fn1();
c.getB().fn2();
}
}
类C既要继承类A又要继承类B，则可将类B的定义放入类C内部，使之成为内部类。

一般情况下 当我们需要在某一情形下实现一个接口，而在另一情形下又不需要实现这个接口时，我们可以使用内部类来解决这一问题。让内部类来实现这个接口。另外一个很好的理由是java内部类加上接口可以有效地实现多重继承。

Ⅸ 什么是内部类内部类有什么作用(java)

在Java中，可以将一个类定义在另一个类里面或者一个方法里面，这样的类称为内部类。广泛意义上的内部类一般来说包括这四种：成员内部类、局部内部类、匿名内部类和静态内部类。下面就先来了解一下这四种内部类的用法。

成员内部类是最普通的内部类，它的定义为位于另一个类的内部，形如下面的形式：

class Circle { double radius = 0; public Circle(double radius) { this.radius = radius; } class Draw { //内部类 public void drawSahpe() { System.out.println("drawshape"); } }}

这样看起来，类Draw像是类Circle的一个成员，Circle称为外部类。成员内部类可以无条件访

class Circle { private double radius = 0; public static int count =1; public Circle(double radius) { this.radius = radius; } class Draw { //内部类 public void drawSahpe() { System.out.println(radius); //外部类的private成员 System.out.println(count); //外部类的静态成员 } }}

不过要注意的是，当成员内部类拥有和外部类同名的成员变量或者方法时，会发生隐藏现象，即默认情况下访问的是成员内部类的成员。如果要访问外部类的同名成员，需要以下面的形式进行访问：

外部类.this.成员变量外部类.this.成员方法

虽然成员内部类可以无条件地访问外部类的成员，而外部类想访问成员内部类的成员却不是这么随心所欲了。在外部类中如果要访问成员内部类的成员，必须先创建一个成员内部类的对象，再通过指向这个对象的引用来访问：

class Circle { private double radius = 0; public Circle(double radius) { this.radius = radius; getDrawInstance().drawSahpe(); //必须先创建成员内部类的对象，再进行访问 } private Draw getDrawInstance() { return new Draw(); } class Draw { //内部类 public void drawSahpe() { System.out.println(radius); //外部类的private成员 } }}

成员内部类是依附外部类而存在的，也就是说，如果要创建成员内部类的对象，前提是必须存在一个外部类的对象。创建成员内部类对象的一般方式如下：
public class Test { public static void main(String[] args) { //第一种方式： Outter outter = new Outter(); Outter.Inner inner = outter.new Inner(); //必须通过Outter对象来创建 //第二种方式： Outter.Inner inner1 = outter.getInnerInstance(); }} class Outter { private Inner inner = null; public Outter() { } public Inner getInnerInstance() { if(inner == null) inner = new Inner(); return inner; } class Inner { public Inner() { } }}

内部类可以拥有private访问权限、protected访问权限、public访问权限及包访问权限。比如上面的例子，如果成员内部类Inner用private修饰，则只能在外部类的内部访问，如果用public修饰，则任何地方都能访问；如果用protected修饰，则只能在同一个包下或者继承外部类的情况下访问；如果是默认访问权限，则只能在同一个包下访问。这一点和外部类有一点不一样，外部类只能被public和包访问两种权限修饰。我个人是这么理解的，由于成员内部类看起来像是外部类的一个成员，所以可以像类的成员一样拥有多种权限修饰。