摘要：
内部类理解外部类并可以与之进行通信。创建一个内部类非常简单，只要在另一个类中定义一个类即可。但是，静态或非静态类可以直接在外部类的方法中创建，如创建方法1中那样。外部类通知此方法以获取内部类对象。非静态内部类不能包含静态数据和字段，也不能包含嵌套类。
说明：内部类和组合是完全不同的概念，内部类看起来更像是一种代码隐藏机制。内部类了解外围类，并能与之通信。要创建一个内部类是非常简单的，只要将一个类定义在另一个类的内部即可。
创建内部类对象的方式：
1.如果内部类为公有、静态内部类：
packagethink.in.java.test; /*** 一个包裹着公有的、静态的、内部类的外部类 * @authorAdministrator * */ public classOuter { privateString oStr; Outer(String oStr){ this.oStr =oStr; } publicInner getInner(String str) { return newInner(str); } public static classInner{ privateString inStr; Inner(String inStr){ this.inStr =inStr; } public voidprint() { System.out.println(this.inStr); } } }
测试程序：
packagethink.in.java.test; importthink.in.java.test.Outer.Inner; /*** 创建公有的、静态的、内部类对象的方式 * @authorAdministrator * */ public classTset { public static voidmain(String[] args) { //创建方式1 Outer o = new Outer("I am outer"); Inner in1 = o.getInner("I am Inner1"); in1.print(); //创建方式2 -- 推荐 Inner in2 = new Inner("I am Inner2"); in2.print(); //创建方式3 Outer.Inner in3 = new Outer.Inner("I am Inner3"); in3.print(); //创建方式4 Outer.Inner in4 = new Inner("I am Inner4"); in4.print(); //Illegal enclosing instance specification for type Outer.Inner //Outer.Inner in5 = o.new Inner("I am Inner5"); } }
输出：
I am Inner1
I am Inner2
I am Inner3
I am Inner4总结：静态内部类不能使用非静态内部类的创建方式，即上测试类中in5对象的创建方式
2.如果内部类为公有、非静态内部类：
packagethink.in.java.test; /*** 一个包裹着公有的、非静态的、内部类的外部类 * @authorAdministrator * */ public classOuter { privateString oStr; Outer(String oStr){ this.oStr =oStr; } publicInner getInner(String str) { //return new Outer.Inner(str); return newInner(str); } public classInner{ privateString inStr; Inner(String inStr){ this.inStr =inStr; } public voidprint() { System.out.println(this.inStr); } } }
测试程序：
packagethink.in.java.test; importthink.in.java.test.Outer.Inner; /*** 创建公有的、非静态的、内部类对象的方式 * @authorAdministrator * */ public classTset { public static voidmain(String[] args) { //创建方式1 Outer o = new Outer("I am outer"); Outer.Inner in1 = o.getInner("I am Inner1"); //Inner in1 = o.getInner("I am Inner1"); in1.print(); //创建方式2 Inner in2 = o.new Inner("I am Inner2"); //Outer.Inner in2 = o.new Inner("I am Inner2"); in2.print(); //error,不能引用外部类的名字去创建这个对象，你应该使用外部类的对象去创建内部类，像in2那样 //Inner in3 = o.new Outer.Inner("I am Inner2"); //error! //Inner in3 = new Outer.Inner("I am Inner3"); //Inner in4 = new Inner("I am Inner3"); //Inner in5 = new Inner("I am Inner5"); } }
输出：
I am Inner1
I am Inner2总结：创建非静态内部类不能使用像静态内部类那样直接创建！但创建静态或非静态类都可以像创建方式1中那样，在外部类的某个方法里直接创建，在由外部类通知这个方法，获取内部类对象。
学习：针对非静态类，在拥有外部类对象之前是不可能创建内部类对象的，这是因为内部类对暗暗地连接到创建它的外部类对象上，这也是为什么非静态内部类具有外部类所有成员访问权的原因，当某个外围类对象创建了一个内部类对象时，此内部类对象必定会秘密捕获一个指向那个外围类对象的引用。然后，在你访问外围类的成员时，就是用那个引用来选择外围类的成员。
对于静态的内部类不具有访问外部类所有成员方法和非静态变量的权利
packagethink.in.java.test; /*** 一个包裹着公有的、非静态的、内部类的外部类 * @authorAdministrator * */ public classOuter { privateString oStr; Outer(String oStr){ this.oStr =oStr; } publicInner getInner(String str) { return newInner(str); } public static voidoPrint(String str) { System.out.println(str); } public static classInner{ privateString inStr; Inner(String inStr){ this.inStr =inStr; } } public static voidmain(String[] args) { Outer o = new Outer("i am outer"); Inner in = new Inner("I am Inner"); System.out.println(o.oStr); //不具有访问外围类属性的权利 //System.out.println(in.oStr); o.getInner("hello"); //不具有访问外围类方法的权利 //in.getInner("hello"); //可以调用外部类静态方法 oPrint("hello"); } }
静态的内部类通常被称为嵌套类，它意味着：
1）要创建嵌套类的对象，并不需要其外围类的对象。
2）不能从嵌套类的对象中访问非静态的外委类对象。
非静态内部类中不能含有静态数据与字段，也不能包含嵌套类。
