一、内部类的定义

        将一个类的定义放在另外一个类的内部,这就是内部类。内部类的特点,我们用一个例子来引出。

/**
 * Created by jay.zhou on 2018/2/23.
 */
public class Outer {
    private int year = 2018;
    class Inner{
        //static int size = 5; 报错
        public void show(){
            System.out.println(year);//内部类直接访问到外部类的成员变量
        }
    }

    public static void main(String[] args) {
        new Outer().new Inner().show();//运行结果:2018
    }
}

当外部类对象创建内部类对象的时候,内部类对象会秘密的捕获创建它的外部类对象的引用。

二、内部类捕获外部类对象的引用 

         普通的成员内部类对象的创建方法是,使用  " 外部类对象. new 内部类名()" ,比如 new Outter(). new Inner()。

        既然当外部类对象创建内部类对象的时候,内部类对象会秘密的捕获那个创建它的外部类对象的引用。那在内部类中如何才能获取到这个引用呢?使用 “外部类类名.this”即可。

/**
 * Created by jay.zhou on 2018/2/23.
 */
public class Outer {
    private int year = 2018;
    class Inner{
        public Outer getOutter(){
            return Outer.this;
        }
    }

    public static void main(String[] args) {
        Outer outer = new Outer();
        Outer outer2 = outer.new Inner().getOutter();
        if(outer.equals(outer2)){
            System.out.println("内部类对象使用 外部类类名.this 返回 创建它的外部类对象的引用");
        }
    }
}

        运行结果是:内部类使用 外部类类名.this 返回 创建它的外部类对象的引用。

        这说明内部类能够使用"外部类类名.this"获取到创建它的外部类对象。

三、几种特殊的内部类

        第一种是嵌套类。嵌套类是使用static 修饰的内部类。嵌套类的特点是:嵌套类的创建不需要外部类对象,并且嵌套类对象不能访问外部类对象的非静态成员。原因很简单,因为嵌套类对象不需要从外部类对象创建,因此也无法捕获到创建它的外部类对象的引用,自然就不能访问到属于外部类对象的普通成员变量和成员方法。嵌套的类名是 "外部类名.内部类名",因此创建嵌套类对象的方法是: new Outter.Inner();

        第二种是匿名内部类。匿名内部类就是没有名字的类。它通过new表达式返回的引用被自动向上转型为其父类。new 父{重写}; 这创建的是父的子类对象。   new 接口 {实现};这创建的是接口的实现类对象。并且匿名内部类对象它是没有构造函数的,因为它没有名字,通常可以使用“构造代码块”当作其构造函数。根据类的初始化过程,创建子类对象之前,它的父类对象必须先要被初始化完毕,因此,父类的构造函数将会被调用。

/**
 * Created by jay.zhou on 2018/2/23.
 */
public abstract class Annimal {
    public Annimal() {
        System.out.println("初始化一个动物");
    }

    public abstract void eat();
}

class Apply{
    public static void apply(Annimal annimal){
        annimal.eat();
    }

    public static void main(String[] args) {
        apply(new Annimal() {
            @Override
            public void eat() {
                System.out.println("某动物在吃东西");
            }
        });
    }
    /**
     * 运行结果:
     * 初始化一个动物
     * 某动物在吃东西
     */
}

当一个方法的参数是一个接口类型的时候,并且这个接口中的方法不超过三个,可以使用匿名内部类作为方法的实际参数进行传递。另外就是当某个类只需要使用一次的时候,也可以考虑使用匿名内部类。

四、内部类存在的意义

        意义一:封装实现细节。下面用个简单的例子来演示一下。

/**
 * Created by jay.zhou on 2018/2/23.
 */
//电源接口有个方法是 发电
public interface PowerSource {
    void power();
}

//发电机,英语太差,只能用拼音了
class FaDianJi {
    //太阳能
    private class TaiYangNeng implements PowerSource {
        @Override
        public void power() {
            System.out.println("太阳能发电成功");
        }
    }

    //电池
    private class DianChi implements PowerSource {
        @Override
        public void power() {
            System.out.println("电池发电成功");
        }
    }

    /**
     * 发电机供电
     *
     * @param b 是否停电
     * @return  能够发电的工具
     */
    public PowerSource power(boolean b) {
        TaiYangNeng taiYangNeng = new TaiYangNeng();
        DianChi dianChi = new DianChi();
        if(b){
            return dianChi;
        }else{
            return taiYangNeng;
        }

    }

    public static void main(String[] args) {
        //有一个发电机
        FaDianJi faDianJi = new FaDianJi();
        //停电了
        PowerSource powerSource = faDianJi.power(true);
        powerSource.power();
        //没停电
        powerSource = faDianJi.power(false);
        powerSource.power();
    }
    /**
     * 运行结果:
     * 电池发电成功
     * 太阳能发电成功
     */
}

         这个例子我想表达出,当某个方法将内部类对象“向上转型”为它的父类的时候,尤其转型成接口类型的时候,它的实现类将完全不可见。在"发电机"类的power(boolean b)方法中,有两个电源PowerSource的实现类,分别是“太阳能”对象和“电池”对象。此方法的返回值是一个接口类型,因此这两个对象在返回的时候将会自动发生“向上转型”。这样做的效果是,在我们只知道返回的是这个接口的实现类对象,无法知道这个类的具体实现。在应用的代码中,比如在主函数中,我们只能通过发电机拿到一个电源接口的实现类对象。但是这个电源是太阳能的,还是电池的,我们在客户端的代码上是看不到的,只知道发电机拿到的是一个电源的实现类对象。

内部类对象向上转型为它的接口形式的时候,在别的类中只能用到此接口的引用,无法知道其实现细节。

内部类间接支持“多重继承”

/**
 * Created by jay.zhou on 2018/2/23.
 */
public class A {
    public void show(){
        System.out.println("父类继承到的show方法");
    }
}

interface B{
     void show();
}

class C extends A {
    private class D implements B{
        @Override
        public void show() {
            System.out.println("内部类实现的show方法");
        }
    }
    public B getD(){
        return new D();
    }
}

class Apply2{
    public static void apply1(A a){
        a.show();
    }

    public static void apply2(B b){
        b.show();
    }

    public static void main(String[] args) {
        C c = new C();
        apply1(c);
        apply2(c.getD());
    }
    /**
     * 父类继承到的show方法
     * 内部类实现的show方法
     */
}

        这个例子想说明:

        类A有一个方法show(),接口B中也有一个抽象方法show()。类C继承了类A并且要求它实现B。

        现在的问题在于,类C如果继承了A的话,那么它将会继承到A的show()方法,这将会自动实现B接口的show()。这并不是我们想要的,我们想要的是类C即要继承A的show()方法,又想自己实现B接口中的show()方法。那么类C使用内部类来实现接口,并且有一个方法将这个内部类对象,也就是这个实现类对象,向上转型为它的接口形式,作为方法的返回值,这个例子就是类C中getD()方法。现在的效果就是:类C的对象,既能作为它的父类A应用到客户端代码中,执行继承到的show()方法,也能作为接口B调用自己实现的show()方法。即继承到了父类的方法,又自己实现了接口中相同的方法。可谓是“既继承,又实现”,有了“多重继承”的感觉。

五、要点

        外部类对象创建内部类对象的时候,内部类对象会秘密的捕获那个创建它的外部类对象的引用。

        当一个方法的参数是一个接口类型的时候,并且这个接口中的方法不超过三个,可以使用匿名内部类作为方法的实际参数进行传递。

        内部类对象向上转型为它的接口形式的时候,在别的类中只能用到此接口的引用,无法知道其实现细节。

        内部类间接的支持了“多重继承”。    

        内部类存在的意义:隐藏实现、多重继承。