内部类

为什么要使用内部类

<Think in Java>这样描述：使用内部类最吸引人的原因是：每个内部类都能独立地继承一个实现。所以无论外围类是否已经继承了某个实现，对于内部类没有影响。

接口知识解决了部分问题，而内部类使得多重继承的解决方案变得更加完整。

内部类优点

• 在单个外围类中，可以让多个内部类以不同方式实现同一接口，或者继承同一个类。
• 创建内部类对象的时候并不依赖外围类对象的创建。
• 内部类没有is-a关系。他就是一个独立的实体。
• 内部类提供了更好的封装，除了外部类。其他类不能访问。

常见内部类分类

成员内部类

可以看成外围类的一个成员，可以无限制访问外围类的所有成员属性和方法；但是外围类要访问内部类的成员属性和方法需要通过内部类实例来访问。

注意事项

• 成员内部类中不能存在任何static的变量和方法。
• 成员内部类是依附于外围类的，所以之后县城建了外围类才能创建内部类。

public class OuterClass {
    private String str;

    public void outerDisplay(){
        System.out.println("outerClass...");
    }

    class InnerClass{
        public void innerDisplay(){
            str = " inner str";
            System.out.println(str);
            outerDisplay();
        }
    }
    //推荐使用这种方式获取成员内部类
    public InnerClass getInnerClass(){
        return new InnerClass();
    }

    public static void main(String [] args){
        OuterClass outerClass = new OuterClass();
        OuterClass.InnerClass innerClass = outerClass.getInnerClass();
        innerClass.innerDisplay();
    }
}

输出结果
 inner str
outerClass...

局部内部类

它只在该方法和属性中被使用，出了该方法和属性就会失效

public class Parcel5 {  
    public Destionation destionation(String str){  
        class PDestionation implements Destionation{  
            private String label;  
            private PDestionation(String whereTo){  
                label = whereTo;  
            }  
            public String readLabel(){  
                return label;  
            }  
        }  
        return new PDestionation(str);  
    }  
      
    public static void main(String[] args) {  
        Parcel5 parcel5 = new Parcel5();  
        Destionation d = parcel5.destionation("chenssy");  
    }  
} 

public class Parcel6 {  
    private void internalTracking(boolean b){  
        if(b){  
            class TrackingSlip{  
                private String id;  
                TrackingSlip(String s) {  
                    id = s;  
                }  
                String getSlip(){  
                    return id;  
                }  
            }  
            TrackingSlip ts = new TrackingSlip("chenssy");  
            String string = ts.getSlip();  
        }  
    }  
      
    public void track(){  
        internalTracking(true);  
    }  
      
    public static void main(String[] args) {  
        Parcel6 parcel6 = new Parcel6();  
        parcel6.track();  
    }  
} 

匿名内部类

public class OuterClass {
    private String str;

    public void outerDisplay(){
        System.out.println("outerClass...");
    }

    public InnerClass getInnerClass(final int num , String str){
        return new InnerClass(){
            int number = num + 3;
            public int getNumber(){
                return number;
            }
        };
    }

    public static void main(String [] args){
        OuterClass out = new OuterClass();
        InnerClass innerClass = out.getInnerClass(2, "chenssy");
        System.out.println(innerClass.getNumber());
    }
}

输出结果
5

• 匿名内部类没有修饰符
• new匿名内部类，这个类首先要存在
• 匿名内部类是没有构造方法的

静态内部类

静态内部类与非静态内部类之间最大的区别在于非静态内部类在编译完成之后会隐含地保存着一个引用，该引用是指向创建它的外围内，但是静态内部类却没有。没有这个引用就意味着：

• 它的创建是不需要依赖于外围类的。
• 它不能使用任何外围类的非static成员变量和方法。