“内部类” 大总结(Java)，内部类总结java

(本文整理自很久以前收集的资料(我只是做了排版修改)，作者小明，链接地址没有找到，总之感谢，小明)

内部类的位置：

内部类可以作用在方法里以及外部类里，作用在方法里称为局部内部类，作用在外部类里分为实例内部类和静态内部类。

外部类和内部类的类访问修饰符：

外部类可以是public和默认的，内部类可以是public,private,protected类型的

内部类和外部类的关系：

*在【实例内部类中】

A：内部类可以访问外部类中所有的任何访问修饰符的成员。

B：而一个外部类实例对应0个或n个内部类实例。在外部类中不能直接访问内部类的成员，必须通过内部类的实例去访问才可以

*在【静态内部类中】

A：静态内部类可以直接访问外部类的静态成员，如果访问外部类的实例成员，就必须通过外部类的实例去访问。在创建内部类的实例的时候，不必创建外部类的实例.。

B：外部类可以通过完整的类名来直接访问静态内部类的静态成员，如果要访问静态内部类的非静态成员则需要创建静态内部类的一个实例才行

public classStaticInnerTest

{public static classA

{public int a = 10;static int b = 100;

}public static voidmain(String[] args)

{

StaticInnerTest.A mya= newStaticInnerTest.A();

mya.a= 1234;

System.out.println(""+mya.a);

}

}

以上是可以运行成功的，已经经过测试

*在【局部内部类中】

A：局部内部类和实例内部类一样，可以访问外部类的所有成员

B：外部类根本不知道局部内部类的存在，所以访问不了。

内部类的分类：

1. 成员内部类(实例内部类，静态内部类)

2. 局部内部类

(一) 成员内部类(类的成员)

* (1)实例内部类:

a.  在创建实例内部类的实例的时候，外部类的实例必须已经存在

Outer.InnerTools its = new Out().new InnerTools();

以上代码等价于：

Outer out = new Outer();

Outer.InnerTools its = out.new InnerTools();

(2) 实例内部类的实例【自动】持有对外部类的实例的引用，所以在实例内部类中

可以直接访问外部类的[所有]成员(这里指的是外部类当中所有的public，protected,private,static的方法和成员变量)

之所以能访问，是因为在实例内部类中需要现有外部类的实例，才能有内部类的实例,参见(1).

Outer.InnerTools its = new Outer().newInnerTools();

【注意：】在多重嵌套中，实例内部类可以访问所有外部类的成员

Class A

{

PrivatevoidmethodA(){}

Class B

{

PrivatevoidmethodB(){}

Class C

{

PrivatevoidMethodC()

{

methodA();

methodB();

}

}

}

}

(3) 在实例内部类中，外部类的实例与内部类的实例是一对多的关系，一个内部类实例

只会引用一个外部类实例，而一个外部类实例对应0个或n个内部类实例，在外部类中【不能】直接访问内部类的成员，必须通过内部类的实例去访问才可以。

注意： 在实例内部类中不能定义静态成员

* (2)静态内部类

Class A

{

Publicstatic classB

{

Int v;

}

}

Class Test

{

Publicvoidtest()

{

A.B b= newA.B();

b.v= 1;

}

}

静态内部类可以直接访问外部类的静态成员，如果访问外部类的实例成员，就必须通过外部类的实例去访问

classA

{private inta1;private static inta2;public static classB

{int b1 =a1;int b2 =a2;int b3 = newA().a1;

}

}

在静态内部类中可以定义静态成员和实例成员

classA

{public static classB

{intv1;static intv2;public static classC

{static intv3;

}

}

}

测试类可以通过完整的类名来直接访问静态内部类的静态成员

classA

{public static classB

{intv1;static intv2;public static classC

{static intv3;intv4;

}

}

}public classClient

{public voidtest()

{

A.B b= newA.B();

A.B.C c= newA.B.C();

b.v1= 1;

b.v2= 1;

A.B.v1= 1//error

A.B.v2= 1;

A.B.C.v3= 1;

}

}

局部内部类是在一个方法当中定义的内部类，它的可见范围是当前方法。和局部变量一样，局部内部类不能使用访问修饰符(public , private , protected)以及static来修饰，局部内部类的特点是：

局部内部类只能在当前方法中使用.

classA

{

B b= new B();//error

public voidmethod()

{classB

{intv1;intv2;classC

{intv3;

}

}

B b= newB();

B.C c= b.newC();

}

}

局部内部类和实例内部类一样，不能包含静态成员。

classA

{public voidmethod()

{classB

{static int v1;//error

intv2;static class C //error

{intv3;

}

}

}

}

在局部内部类中定义的内部类同样也不能被public  protected, private这些访问修饰符修饰(局部内部类不能被public  protected  private访问修饰符修饰)

局部内部类和实例内部类一样，可以访问外部类的所有成员，此外，局部内部类还可以访问所在方法中的final类型的参数和变量

classA

{inta;public void method(final int p1,intp2)

{int localV1 = 1;final int localV2 = 2;classB

{int b1 =a;int b2 =p1;int b3 = p2;//error

int b4 = localV1//error

int b5 =localV2;

}

}

}

匿名内部类本身没有构造器，但是会调用父类中的构造器。

public classA

{

A(inty)

{

System.out.println("不是默认构造器");

}

A()

{

System.out.println("默认构造器");

}voidmethod()

{

System.out.println("from A");

}public static voidmain(String[] args)

{//new A().method();//默认构造器，from A

A a= newA()

{voidmethod()

{

System.out.println("我是匿名内部类中的method方法");

}

}/*也就是说匿名构造器会自动调用父类中的构造器*/a.method();//默认构造器，我是匿名内部类中的method方法

}

}

(2) 匿名内部类尽管没有构造方法，但是可以在匿名内部类中提供一段实例初始化代码，Java虚拟机会在调用了父类的构造方法之后，执行这段代码。

public static voidmain(String [] args)

{int v = 1;

A a= newA(v)

{

{

System.out.println("init instance");

}voidmethod()

{

System.out.println("from anonymous");

}

};

a.method();

}

程序执行结果如下：

another constructer//父类当中的构造器执行的结果

init instance

from anonymous

补充：

abstract classA

{

A a= newA()

{voidmethod()

{

System.out.println("inner");

}

}abstract voidmethod();

}

匿名内部类除了可以继承类外，还可以实现接口【重点】

Ccass Sample

{public static voidmain(String [] args)

{

Thread t= new Thread(newRunnable()

{public voidrun()

{for(int i = 0; i < 100; i++)

{

System.out.print(i);

}

}

});

}

}

匿名内部类同局部内部类一样，可以访问外部类的所有成员，如果匿名内部类位于一个方法中，还能访问所在方法的final类型的变量和参数

局部内部类和匿名内部类一样，名字在方法外都是不可见的，因此都可以起到封装类型名字的作用。

【匿名内部类和局部内部类的区别】

1. 匿名内部类的程序代码量少

2. 一个局部内部类可以有多个重载构造方法，并且测试类可以多次创建局部内部类的实例。而匿名内部类没有重载构造方法之说，并且只能创建一次实例。

因此，如果只需要创建内部类的一个实例，可以使用匿名内部类，它能使程序代码简洁明了，如果需要多次创建内部类的实例，那么使用局部内部类。

内部类小结：

作者：  小明

参考资料： <>

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);

}

}

......余下全文>>

java中静态内部类与内部类的不同

和普通的类一样，内部类也可以有静态的。不过和非静态内部类相比，区别就在于静态内部类没有了指向外部的引用。这实际上和C++中的嵌套类很相像了，Java内部类与C++嵌套类最大的不同就在于是否有指向外部的引用这一点上，当然从设计的角度以及以它一些细节来讲还有区别。

除此之外，在任何非静态内部类中，都不能有静态数据，静态方法或者又一个静态内部类(内部类的嵌套可以不止一层)。不过静态内部类中却可以拥有这一切。

http://www.dengb.com/Javabc/898010.htmlwww.dengb.comtruehttp://www.dengb.com/Javabc/898010.htmlTechArticle“内部类” 大总结(Java)，内部类总结java (本文整理自很久以前收集的资料(我只是做了排版修改)，作者小明，链接地址没有找到，总之感谢...