嵌套类和内部类

以前一直不怎么理解,今天在网上查了查,看到一篇解释不错的(有代码有解释),粘过来好好看看。

      可以在一个类的内部定义另一个类,这种类称为嵌套类(nested classes),它有两种类型:静态嵌套类和非静态嵌套类。静态嵌套类使用很少,最重要的是非静态嵌套类,也即是被称作为内部类(inner)。嵌套类从JDK1.1开始引入。

其中inner类又可分为三种:   

其一、在一个类(外部类)中直接定义的内部类;   

其二、在一个方法(外部类的方法)中定义的内部类;   

其三、匿名内部类。

下面,我将说明这几种嵌套类的使用及注意事项。

二、静态嵌套类

  如下所示代码为定义一个静态嵌套类,

  1. public class StaticTest {   
  2.     private static String name = "javaJohn";           
  3.   private String id = "X001";  
  4.   static class Person{  
  5.     private String address = "swjtu,chenDu,China";  
  6.     public String mail = "josserchai@yahoo.com";//内部类公有成员  
  7.     public void display(){  
  8.       //System.out.println(id);//不能直接访问外部类的非静态成员  
  9.       System.out.println(name);//只能直接访问外部类的静态成员  
  10.       System.out.println("Inner "+address);//访问本内部类成员。  
  11.     }  
  12.   }  
  13.   
  14.   public void printInfo(){  
  15.     Person person = new Person();  
  16.     person.display();  
  17.     //System.out.println(mail);//不可访问  
  18.     //System.out.println(address);//不可访问  
  19.     System.out.println(person.address);//可以访问内部类的私有成员  
  20.     System.out.println(person.mail);//可以访问内部类的公有成员  
  21.   
  22.   }  
  23.   public static void main(String[] args) {  
  24.   StaticTest staticTest = new StaticTest();  
  25.   staticTest.printInfo();  
  26. }  
  27. }  

  在静态嵌套类内部,不能访问外部类的非静态成员,这是由Java语法中"静态方法不能直接访问非静态成员"所限定。若想访问外部类的变量,必须通过其它方法解决,由于这个原因,静态嵌套类使用很少。注意,外部类访问内部类的的成员有些特别,不能直接访问,但可以通过内部类来访问,这是因为静态嵌套内的所有成员和方法默认为静态的了。同时注意,内部静态类Person只在类StaticTest 范围内可见,若在其它类中引用或初始化,均是错误的。

三、在外部类中定义内部类

  1、内部类分为成员内部类、静态嵌套类、方法内部类、匿名内部类。

      几种内部类的共性:
      A、内部类仍然是一个独立的类,在编译之后会内部类会被编译成独立的.class文件,但是前面冠以外部类的类命和$符号。
      B、内部类不能用普通的方式访问。内部类是外部类的一个成员,因此内部类可以自由地访问外部类的成员变量,无论是否是private的。

如下所示代码为在外部类中定义两个内部类及它们的调用关系

  1. public class Outer {   
  2.         int outer_x = 100;  
  3.     class Inner{  
  4.       public int y = 10;  
  5.       private int z = 9;  
  6.       int m = 5;  
  7.       public void display(){  
  8.         System.out.println("display outer_x:"+ outer_x);  
  9.       }  
  10.       private void display2(){  
  11.         System.out.println("display outer_x:"+ outer_x);  
  12.       }  
  13.     }  
  14.     void test(){  
  15.       Inner inner = new Inner();  
  16.       inner.display();  
  17.       inner.display2();  
  18.       //System.out.println("Inner y:" + y);//不能访问内部内变量  
  19.       System.out.println("Inner y:" + inner.y);//可以访问  
  20.       System.out.println("Inner z:" + inner.z);//可以访问  
  21.       System.out.println("Inner m:" + inner.m);//可以访问  
  22.       InnerTwo innerTwo = new InnerTwo();  
  23.       innerTwo.show();  
  24.     }  
  25.     class InnerTwo{  
  26.       Inner innerx = new Inner();  
  27.       public void show(){  
  28.         //System.out.println(y);//不可访问Innter的y成员  
  29.         //System.out.println(Inner.y);//不可直接访问Inner的任何成员和方法  
  30.         innerx.display();//可以访问  
  31.         innerx.display2();//可以访问  
  32.         System.out.println(innerx.y);//可以访问  
  33.         System.out.println(innerx.z);//可以访问  
  34.         System.out.println(innerx.m);//可以访问  
  35.       }  
  36.     }  
  37.     public static void main(String args[]){  
  38.       Outer outer = new Outer();  
  39.       outer.test();  
  40.     }  
  41.   }  

总结:

        1、对于内部类,通常在定义类的class关键字前不加public 或 private等限制符,若加了没有任何影响。

        2、内部类中可以直接访问外部类的数据成员和方法。

        3、另外,就是要注意,内部类Inner及InnterTwo只在类Outer的作用域内是可知的,如果类Outer外的任何代码尝试初始化类Inner或使用它,编译就不会通过。同时,内部类的变量成员只在内部内内部可见,若外部类或同层次的内部类需要访问,需采用示例程序中的方法,不可直接访问内部类的变量。

四、方法内部类

   顾名思义,把类放在方法内。  

  1. class Outer {  
  2.     public void doSomething(){  
  3.         class Inner{  
  4.             public void seeOuter(){  
  5.               
  6.             }  
  7.         }      
  8.     }  
  9. }  


A、方法内部类只能在定义该内部类的方法内实例化,不可以在此方法外对其实例化。
B、方法内部类对象不能使用该内部类所在方法的非final局部变量。
      因为方法的局部变量位于栈上,只存在于该方法的生命期内。当一个方法结束,其栈结构被删除,局部变量成为历史。但是该方法结束之后,
在方法内创建的内部类对象可能仍然存在于堆中!例如,如果对它的引用被传递到其他某些代码,并存储在一个成员变量内。
      正因为不能保证局部变量的存活期和方法内部类对象的一样长,所以内部类对象不能使用它们。
下面是完整的例子:

  1. class Outer {  
  2.     public void doSomething(){  
  3.         final int a =10;  
  4.         class Inner{  
  5.             public void seeOuter(){  
  6.                 System.out.println(a);  
  7.             }  
  8.         }     
  9.         Inner in = new Inner();  
  10.         in.seeOuter();   
  11.     }  
  12.     public static void main(String[] args) {  
  13.         Outer out = new Outer();  
  14.         out.doSomething();  
  15.     }  
  16. }  

五、匿名内部类

  匿名内部类也就是没有名字的内部类,正因为没有名字,所以匿名内部类只能使用一次,它通常用来简化代码编写

但使用匿名内部类还有个前提条件:必须继承一个父类或实现一个接口。

A、继承式的匿名内部类。    

  1.  class Car {  
  2.     public void drive(){  
  3.         System.out.println("Driving a car!");  
  4.     }  
  5. }  
  6.       
  7. class Test{  
  8.     public static void main(String[] args) {  
  9.         Car car = new Car(){  
  10.             public void drive(){  
  11.                 System.out.println("Driving another car!");  
  12.             }  
  13.         };  
  14.         car.drive();  
  15.     }  
  16. }  

结果输出了:Driving another car! Car引用变量不是引用Car对象,而是Car匿名子类的对象。
B、接口式的匿名内部类。

  1. interface  Vehicle {  
  2.     public void drive();  
  3. }  
  4.       
  5. class Test{  
  6.     public static void main(String[] args) {  
  7.         Vehicle v = new Vehicle(){  
  8.             public void drive(){  
  9.                 System.out.println("Driving a car!");  
  10.             }  
  11.         };  
  12.         v.drive();  
  13.     }  
  14. }  

上面的代码很怪,好像是在实例化一个接口。事实并非如此,接口式的匿名内部类是实现了一个接口的匿名类。而且只能实现一个接口。
C、参数式的匿名内部类。

    1. class Bar{  
    2.     void doStuff(Foo f){}  
    3. }  
    4. interface Foo{  
    5.     void foo();  
    6. }  
    7. class Test{  
    8.     static void go(){  
    9.         Bar b = new Bar();  
    10.         b.doStuff(new Foo(){  
    11.             public void foo(){  
    12.                 System.out.println("foofy");  
    13.             }  
    14.         });  
    15.     }  
    16. }  
原文地址:https://www.cnblogs.com/lzb1991/p/6513314.html