内部类

内部类

内部类是可以将一个类定义放在另一个类的定义内部。

为什么需要内部类

每个内部类都能独立的集成一个接口实现，无论外围类是否已经继承接口的实现，对于内部类都没有影响

内部类的创建

如果想在另一个类中使用内部类（非静态的）那它的使用类型该怎么描述呢？
OuterClassName.InnerClassName

class OuterClass {

    private String outParam = "outParam";

    class InnerClass{
        private String inParam = "innerParam";

        InnerClass(){
            System.out.println("innerClass");
            System.out.println(outParam);
            toUse();
        }

    }

    public  InnerClass to(){
        return new InnerClass();
    }

    public void toUse(){
        System.out.println("innerClass use OuterClass method");
    }

    public static void main(String[] args) {

        OuterClass out = new OuterClass();
        OuterClass.InnerClass inner = out.to();
    }
结果：
innerClass
outParam
innerClass use OuterClass method

这里使用 OuterClass.InnerClass 来指明内部类的类型，然后同时也可以发现内部类也可以使用外部类的成员，即使是私有类型的。

内部类拥有其外围类的所有元素访问权。

内部类访问此外围对象时，内部类会指向那个外围类对象的引用来选择外围对象的成员

.this 与 .new

.this是生成对外部类的引用，.new是创建某个内部类，一个由内到外一个由外到内

class OuterClass {

    void f() {
        System.out.println("OuterClass.f()");
    }

    class InnerClass {
        public OuterClass outer() {
            return OuterClass.this;
        }
        InnerClass(){
            System.out.println("InnerClass");
        }

    }

    public InnerClass getInnerClass(){
        return new InnerClass();
    }

    public static void main(String[] args) {
        OuterClass out = new OuterClass();
        out.getInnerClass().outer().f();

        OuterClass.InnerClass innerClass = out.new InnerClass();

    }

}
结果：
InnerClass
OuterClass.f()
InnerClass

OuterClass.this返回的是外部类对象的引用，out.new InnerClass()是创建该内部类，注意不是OuterClass.new InnerClass();

匿名内部类

public interface Contents {
    int value();
}

class Parcel7 {
    public Contents contents() {
        return new Contents() {
            private int i = 11;

            public int value() {
                return i;
            }
        };
    }
}

这个类是匿名的，他没有名字，通过new表达式返回,匿名内部类末尾的分号，并不是标记内部类的结束，而是标记表达式的结束。

如果基类需要一个有参数的构造器

class Parcel8 {
    public Wrapping wrapping(int x){
        return new Wrapping(x){
            public int value(){
                return super.value()*47;
            }

        };
    }
}

如果匿名内部类希望使用一个外部定义的对象，那么要求其参数的引用是final的

class Parcel9 {
    public Destination destination(final String dest){
        return new Destination() {
            private String label = dest;
            public String readLabel() {
                return label;
            }
        };
    }
}

局部内部类

局部内部类就是定义在方法中或作用域中的类

class A {
    private String aaa = "aaa";

    public B b(String param) {
        class BC extends B {
            BC(String param) {
                super(param);
            }

            void f() {
                aaa = "123";
            }
        }
        return new BC(param);
    }

    public void c(Boolean b){
        if(b){
            class C{
                //
            }
        }
    }

    void toBC() {
        new A().b("");
        new BC();//编写有误
    }
}

上面的例子中实例化局部内部类BC()时出现编写错误，而通过执行b方法才能创建局部内部类实例,说明BC是b方法的一部分而不是A类的一部分。

嵌套类

嵌套类是用static修饰的内部类，所以不用其外围对象就可创建，同时也不能使用外围类中的非静态成员了

class D {

    private String outParam1 = "";
    private static String OutParam2 = "";

    public static class innerD implements InterFaceClass {
        public void f() {
            outParam1 = "aaa";//编写错误
            OutParam2 = "bbb";
        }
    }

    public static void main(String[] args) {
        new innerD();
    }
}

接口内部类：一般情况下接口类是不能实现方法的，但是嵌套类可以写在接口类中，在接口类中嵌套类不用声明static关键字，它会自动的修饰为public和static的，所以这就不违反接口的规则了,而且还可以实现接口

public interface E {
    class Test implements InterFaceClass {
        public void f() {
            System.out.println("E.Test");
        }
    }
}
public static void main(String[] args) {
        new E.Test().f();
    }

结果：
E.Test