内部类

内部类分类以及特性

 

成员内部类

public class Outter{
    private int age;
    public String name;

    public class Inner{
        public static final int MAX = 33666;
        String outterName = Outter.this.name;
    }

    public static void main(String[] args){
        Outter out = new Outter();
        Inner inner = out.new Inner();
    }
}

1. 声明在一个类声明中的类。
2. 内部的类可以让任何修饰符修饰。
3. 编译时会生成两个.class文件：Outter.class{} & Outter$Inner.class{}
4. 成员内部类中不能有任何static修饰的变量和方法。但是可以拥有常量（因为常量编译时会被存入运行时常量区）。

 

局部内部类

public class Outter{
    private int age;
    public String name;

    public void show(int b){
        int a = 20;
        class Inner{
            int c = a + 2;
            public void getName(){
               System.out.println(age);
            }
        }

        Inner inner = new Inner();
        inner.getName();
    }

    public static void main(String[] args){
        Outter out = new Outter();
       // Inner inner = out.new Inner();
        out.show(12);
    }
}

1. 声明在一个方法体内部，在所属方法外部无法访问该内部类。
2. 局部内部类不能使用public/protected/private/static修饰。
3. 在局部内部类中只能使用外部定义的final修饰的对象。

 

匿名内部类

public class Outter{
    private int age;
    public String name;
    public InnerClass getInner() {
        return new InnerClass() {
            public int getNumber() {
                return 10;
            }
        };
    };

    public static void main(String[] args){
        Outter out = new Outter();
    }
}
interface InnerClass{
    int getNumber();
}

1. 没有名字的局部内部类。
2. 直接使用new来生成一个对象的引用。
3. 匿名内部类不能定义构造函数或者任何静态成员变量以及静态方法。
4. 匿名内部类返回一个类或者接口的子类对象。
5. 在匿名内部类中只能使用外部定义的final修饰的对象。
   1. 内部类和外部类属于同一个层次，不会因为外部类的方法执行结束，内部类就会像方法一样在内存中被销毁。
   2. 同时，外部类方法中的局部变量就被销毁了，于是内部类可能在访问一个空的变量。
   3. 因为b)，JVM会在将局部变量被内部类使用时，将局部变量复制成为内部类的成员变量。
   4. 但是从程序员的角度，并不知道从前的变量被拷贝了，所以在操作内部类成员变量的时候，为了使两个变量的值保持一致。Java就规定必须使用final修饰的变量。

 

嵌套类

public class Outter{
    private String password;
    private int age;

    public static class Inner{
        public static int zipcode;
        public String address;

        public void f1(){
            ******
        }    
    }

}

1. 使用static修饰的内部类。
2. 编译时会分出两个不同的class文件文件。
3. 在静态内部类中
   1. 不需要通过外围对象访问内部类的属性/引用。
   2. 内部类中无法再访问外部类中非静态的方法/属性/引用。