class Outer{
public class InnerTool
{
public int add(int a,int b){
return a+b;
}
}
private InnerTool tool=new InnerTool();//建立内部类的对象，并把对象的引用私有化
public void add(int a,int b,int c)
{
tool.add(tool.add(a,b),c);
}
}
public class Tester
{
public static void main(String args[]){
Outer o=new Outer();
o.add(1,2,3);
Outer.InnerTool tool=new Outer().new InnerTool();
}
}
通过这段代码可以得出：
1，可以在外部类的成员位置，建立内部类的对象。
2，内部类的完整类名是 ：外部类名.内部类名，如果外部其他类如本例子(Tester)，要访问内部类，则必须使用内部类的全名
如：Outer.InnerTool tool=new Outer().new InnerTool();
3，如果不想内部类被外部其他类访问，可以为内部类添加私有。
4，无论内部类定义在局部位置，还是成员位置，都不可以与外部类同名。
//当内部类出现在成员位置上，而且非静态时，我们称之为实例内部类
如：
class A
{
class B
{
//B就是实例内部类
}
}
实例内部类的特点：
1，在创建实例内部类的实例时，外部类的实例必须先存在。
如： A.B ab=new A().new B();//A必须先有实例
等同于：
A a=new A();
A.B b=a.new B();
2,实例内部类的实例持有外部类实例的引用，在内部类中，可以访问外部类的所有成员。
为什么？因为当实例内部类建立的时候，外部类的实例必然已经有了，内部类实例自动的持有外部类的实例引用。
3，多重嵌套的内部类同样也可以访问外部类的所有成员。
如：
class A
{
class B
{
class C
{
//内部类C一样可以访问B和A的私有成员。
}
}
}
4，外部类和内部类实例是一对多的关系，一个内部类实例只会引用一个外部类实例，而一个外部类实例则引用多个内部类实例。
外部类中不可以直接访问内部类的成员，必须通过内部类的对象实例去访问。
5，在实例内部类中不可以定义静态成员，只能定义实例成员。
6，如果内部类和外部类包含相同名字的成员，那么在内部类中，该成员为this.成员，而外部成员为外部类名.this(或内部类名).成员。
静态内部类的特点：
1，静态内部类的实例不会自动持有外部类的特定实例的引用，所以在创建静态内部类的时候，不需要创建外部类的实例。
如：
class A
{
static class B
{
}
}
class Demo
{
public static void main(String[]args)
{
//要创建静态内部类的实例，可以直接创建
A.B b=new A.B();
}
}
2,静态内部类可以直接访问外部类的静态成员，如果要访问外部类的实例成员，则必须建立外部类的实例对象。
3，静态内部类可以定义静态成员和实例成员。
4，外部其他类可以通过完整的类名去访问内部类的静态成员，但却不能以这种方式访问内部类实例成员。
class A
{
static class B
{
static int a;
int b;
}
}
class Demo
{
public static void main(String[]args)
{
A.B.a=2;//合法
A.B.b=1;//不可以以类名的形式直接访问成员变量
}
}
局部内部类的特点：
1，局部内部类只能在当前方法中使用。
class A
{
public void show()
{
class B
{
int v=1;
class C
{
}
}
}
}
//show()内可以访问类B和类C，show()方法之外就不可以访问了。
2，局部内部类和实例内部类一样，不能包含静态成员
3，局部内部类中定义的内部类不可以被访问控制修饰符修饰
4，局部内部类可以访问所有外部类的成员，此外，局部内部类还可以访问所在方法中final类型的参数和变量
class A
{
public void show(final int p1,int p2)
{
int v1=1;
final int v2=2;
class B
{
int a=p1;//ok
int b=p2;//no,没被final修饰的参数
int c=v1;//no
}
}
}
|
|
收藏
淘帖
踩
