重新开始学习javase_内部类

转（http://www.cnblogs.com/dolphin0520/p/3811445.html）

内部类：

在Java 1.1 中，可将一个类定义置入另一个类定义中。这就叫作“内部类”。创建内部类的过程是平淡无奇的：将类定义置入一个用于封装它的类内部

一，内部类的种类：

1. 成员内部类
   

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

    这个时候Draw这个类好比于Circle类中的一个成员，Circle称为Draw的外部类，Draw为Circle的成员内部类，所以像成员方法一下无条件的访问Circle中属性和方法，包括private修辞的成员，反之不行;
   当外部类与内部类的成员属性名一致的时候，默认访问的是内部类的属性，若想访问外部类的成员：Outer.this.***;

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

    

   
   
   虽然成员内部类可以无条件地访问外部类的成员，而外部类想访问成员内部类的成员却不是这么随心所欲了。在外部类中如果要访问成员内部类的成员，必须先创建一个成员内部类的对象，再通过指向这个对象的引用来访问(其实这个时候，这个内部类和普通的一个类也没什么区别了):

   class Circle {
       
       public void sysoI(){
           System.out.println(new Draw().i);
       }
       class Draw {     //内部类
           public int i=3;
       }
   }

    

   
   成员内部类是依附外部类而存在的，也就是说，如果要创建成员内部类的对象，前提是必须存在一个外部类的对象。创建成员内部类对象的一般方式如下：

   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和包访问两种权限修饰。我个人是这么理解的，由于成员内部类看起来像是外部类的一个成员，所以可以像类的成员一样拥有多种权限修饰。

   class Circle {
       public class Draw1 {     //内部类
           public int i=3;
       }
       protected class Draw2 {     //内部类
           public int i=3;
       }
       class Draw3 {     //内部类
           public int i=3;
       }
       private class Draw4 {     //内部类
           public int i=3;
       }
          
   }

    

   
   
   

2. 局部内部类
   局部内部类是定义在一个方法或者一个作用域里面的类，它和成员内部类的区别在于局部内部类的访问仅限于方法内或者该作用域内。（一定程序上可以将其看作是一个局部变量一样，比如说：局部内部类就像是方法里面的一个局部变量一样，是不能有public、protected、private以及static修饰符的。）
   

   class People{
       public People() {
            
       }
   }
    
   class Man{
       public Man(){
            
       }
        
       public People getWoman(){
           class Woman extends People{   //局部内部类
               int age =0;
           }
           return new Woman();
       }
   }

    

   
   
   
3. 匿名内部类
   匿名内部类应该是平时我们编写代码时用得最多的，在编写事件监听的代码时使用匿名内部类不但方便，而且使代码更加容易维护。
   

   class Demo8_7 extends JPanel{
       public static void main(String[] args) {
           JButton b=new JButton();
           b.addActionListener(new ActionListener() {
               
               @Override
               public void actionPerformed(ActionEvent e) {
                   // TODO Auto-generated method stub
                   
               }
           });
       }
   }

    就是匿名内部类的使用。代码中需要给按钮设置监听器对象，使用匿名内部类能够在实现父类或者接口中的方法情况下同时产生一个相应的对象，但是前提是这个父类或者接口必须先存在才能这样使用。同样的，匿名内部类也是不能有访问修饰符和static修饰符的。
   
   
   匿名内部类是唯一一种没有构造器的类。正因为其没有构造器，所以匿名内部类的使用范围非常有限，大部分匿名内部类用于接口回调。匿名内部类在编译的时候由系统自动起名为Outter$1.class。一般来说，匿名内部类用于继承其他类或是实现接口，并不需要增加额外的方法，只是对继承方法的实现或是重写。

4. 静态内部类
   静态内部类也是定义在另一个类里面的类，只不过在类的前面多了一个关键字static。静态内部类是不需要依赖于外部类的，这点和类的静态成员属性有点类似，并且它不能使用外部类的非static成员变量或者方法，这点很好理解，因为在没有外部类的对象的情况下，可以创建静态内部类的对象，如果允许访问外部类的非static成员就会产生矛盾，因为外部类的非static成员必须依附于具体的对象。
   
   
   

   关于静态内部类的初始化（笔者的jdk1.8）：

   @Test
       public void test07() {
           Inner_Demo1_7 d=new Inner_Demo1_7();
           d.testa();//方法一
           
           Outter_Demo1_7.Inner_Demo1_7 d2=new Outter_Demo1_7.Inner_Demo1_7();
           d2.testa();//方法二
           
       }    
   
    
   class Outter_Demo1_7 {
       public Outter_Demo1_7() {
            
       }
        
       static class Inner_Demo1_7 {
           public Inner_Demo1_7() {
                
           }
           public void testa(){
               System.out.println(111);
           }
       }
   }

    
   
   

5. 补充(一)：
   在java（1.8以下）中， 方法的内部类可以访问方法中的局部变量，但必须用final修饰才能访问。
   
   原因：
   因为生命周期的原因。方法中的局部变量，方法结束后这个变量就要释放掉，final保证这个变量始终指向一个对象。
   
   首先，内部类和外部类其实是处于同一个级别，内部类不会因为定义在方法中就会随着方法的执行完毕而跟随者被销毁。问题就来了，如果外部类的方法中的变量不定义final，那么当外部类方法执行完毕的时候，这个局部变量肯定也就被GC了，然而内部类的某个方法还没有执行完，这个时候他所引用的外部变量已经找不到了。如果定义为final，java会将这个变量复制一份作为成员变量内置于内部类中，这样的话，由于final所修饰的值始终无法改变，所以这个变量所指向的内存区域就不会变（Java采用了一种copy   local   variable(复制局部变量)的方式来实现，也就是说把定义为final的局部变量拷贝过来用，而引用的也可以拿过来用，只是不能重新赋值。从而造成了可以access   local   variable(访问局部变量)的假象，而这个时候由于不能重新赋值，所以一般不会造成不可预料的事情发生。-------使用final修饰符不仅会保持对象的引用不会改变, 而且编译器还会持续维护这个对象在回调方法中的生命周期. 所以这才是final变量和final参数的根本意义.）
   
   但是在jdk1.8中是可以直接访问的：
   
   

       @Test
       public void test07() {
           new Circle().test(2);
           
       }    
   
   
   
   class Circle {
       int a=1;
          public Circle test(int c){
              int i=2;
              class Circle_sub extends Circle{
                  public Circle_sub() {
                   System.out.println(c);
                   System.out.println(i);
                   System.out.println(a);
               }
              }
              return new Circle_sub();
          }
   } 

    

6. 内部类的使用场景及好处
   

   　为什么在Java中需要内部类？总结一下主要有以下四点：

   　　1.每个内部类都能独立的继承一个接口的实现，所以无论外部类是否已经继承了某个(接口的)实现，对于内部类都没有影响。内部类使得多继承的解决方案变得完整，

   　　2.方便将存在一定逻辑关系的类组织在一起，又可以对外界隐藏。

   　　3.方便编写事件驱动程序

   　　4.方便编写线程代码

7. 补充(二)
   

   最后补充一点知识：关于成员内部类的继承问题。一般来说，内部类是很少用来作为继承用的。但是当用来继承的话，要注意两点：

   　　1）成员内部类的引用方式必须为 Outter.Inner.

   　　2）构造器中必须有指向外部类对象的引用，并通过这个引用调用super()。这段代码摘自《Java编程思想》
   
   

   class WithInner {
       class Inner{
            
       }
   }
   class InheritInner extends WithInner.Inner {
         
       // InheritInner() 是不能通过编译的，一定要加上形参
       InheritInner(WithInner wi) {
           wi.super(); //必须有这句调用
       }
     
       public static void main(String[] args) {
           WithInner wi = new WithInner();
           InheritInner obj = new InheritInner(wi);
       }
   }