OnJava8_内部类

一个定义在另一个类中的类，叫作内部类。

• 内部类自动拥有对其外围类所有成员的访问权。这是如何做到的呢？
  当某个外围类的对象创建了一个内部类对象时，此内部类对象必定会秘密地捕获一个指向那个外围类对象的引用。然后，在你访问此外围类的成员时，就是用那个引用来选择外围类的成员。
  因此，内部类的对象只能在与其外围类的对象相关联的情况下才能被创建（就像你应该看到的，内部类是非 static 类时）。构建内部类对象时，需要一个指向其外围类对象的引用。
• 创建内部类对象的方法：（由上一条可知，创建内部类对象必须由外围类对象而来）

//第一种方法
class OutterClass{
    InnerClass returnInObject(){
        return new InnerClass();
    }
    public static void main (String[] args){
        OutterClass outObject = new OutterClass();
        OutterClass.InnerClass inObject = outObject.returnInObject();
    }
}
//第二种方法
class OutterClass{
    InnerClass {};
    public static void main (String[] args){
        OutterClass outObject = new OutterClass();
        OutterClass.InnerClass inObject = outObject.new InnerClass();
    }
}
}

• 既然知道了从外部类对象如何创建内部类，并且内部类可以捕获外部类对象的引用，那如何获取这个外部类对象引用呢？
  从下面例子可以看出，这是通过外部类名+.this实现的。

public class DotThis {

    void f(){
        System.out.println("DotThis.f()");
    }
    public class Inner{
        public DotThis outer(){
            return DotThis.this;
        }
    }
    public Inner inner(){
        return new Inner();
    }
    public static void main(String []args){
        DotThis dt = new DotThis();
        DotThis.Inner dti = dt.inner();
        dti.outer().f();
        DotThis.Inner dtiNew = dt. new Inner();

    }
}

• 一个定义在方法中的类：

public class Parcel55 {
    public Destination destination(String s){
        final class PDestination implements Destination{
            private String label;
            @Override
            public String readLable() {
                return label;
            }
            private PDestination(String whereTo){
                label = whereTo;
            }
        }
        return new PDestination(s);
    }
    public static void main(String []args){
        Parcel55 p = new Parcel55();
        Destination d = p.destination("qinxiaoyu");
    }
}

• 一个定义在作用域内的类，此作用域在方法的内部：

package innerclasses;

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("slip");
            String s = ts.getSlip();
        }
    }

    public void track() {
        internalTracking(true);
    }

    public static void main(String[] args) {
        Parcel6 p = new Parcel6();
        p.track();
    }
}

嵌套类

普通的内部类对象隐式的保存了一个指向创建它的外围类对象的引用。而声明为static的内部类，即嵌套内部类，具有以下特性：

• 要创建嵌套类的对象，并不需要其外围类的对象。
• 不能从嵌套类的对象中访问非静态的外围类对象。
• 嵌套内部类可以包含 static 数据，static 字段和嵌套类。

接口内部的类

所以想要创建某些公共代码，使得它们可以被某个接口的所有不同实现所共用，可以使用接口内部类还可以使用default和static方法。

public interface ClassInInterface {
    void howdy();

    class Test implements ClassInInterface {

        @Override
        public void howdy() {
            System.out.println("Howdy!");
        }

        public static void main(String[] args) {
            new Test().howdy();
        }
    }
}

内部类的优势：
1、每个内部类继承一个类或者实现一个接口，内部类将实现进行封装，利于低耦合。
2、内部类可以访问外围类的任意成员。
3、多个内部类可以继承同一类或实现同一接口，不同内部类执行不同动作。