初识Java 9-2 内部类

目录

为什么需要内部类

闭包和回调

内部类和控制框架

继承内部类

内部类的重写（并不能）

局部内部类

内部类标识符

---

本笔记参考自： 《On Java 中文版》

---

为什么需要内部类

        在一些情况下，我们无法享受接口带来的便利，有时却还是需要处理多个实现。这就引出了使用内部类的理由之一：

        每个内部类都可以单独地继承自一个实现。因此，外部类是否已经继承了某个实现，对内部类并没有限制。

        内部类的存在完善了多重继承问题的解决方案。因为内部类实际上支持的是“多重实现继承”，也就是说，内部类实际上支持我们继承多个非接口类型。例如：现在需要在一个类中以某种方式实现两个接口。这时有两个选择，① 一个单独的类；② 一个内部类。

    （假设无论使用哪种方法，得到的代码结构都会有意义。）

package mui;

interface A {}

interface B {}

// 方法1：使用单独的类进行实现
class X implements A, B {}

// 方法2：使用内部类进行实现
class Y implements A {
    B makeB() {
        return new B() {};
    }
}

public class MultiInterfaces {
    static void takesA(A a) {}

    static void takesB(B b) {}

    public static void main(String[] args) {
        X x = new X();
        Y y = new Y();

        takesA(x);
        takesA(y);

        takesB(x);
        takesB(y.makeB());
    }
}

        若没有其他限制，从实现的角度而言，上述的方法没有太大区别，都可以使用。

        但若使用的是抽象类或是具体类，而不是接口。此时仍然要求某个类必须以某种方式实现这两者，此时就只能使用内部类了：

class D {}

abstract class E {}

class Z extends D {
    E makE() { // 通过内部类，可以实现“多重实现继承”
        return new E() {};
    }
}

public class MultiImplementation {
    static void takesD(D d) {}

    static void takesE(E e) {}

    public static void main(String[] args) {
        Z z = new Z();
        takesD(z);
        takesE(z.makE());
    }
}

总结内部类的功能：

• 内部类可以有多个实例，其中的每个实例都有自己的状态信息，独立鱼外围类对象的信息。
• 一个外围类中可以有多个内部类，这些内部类可以通过不同的方式实现同一个接口。
• 内部类对象的创建时机不会与外围类对象的创建捆绑在一起。
• 内部类不存在可能引起混淆的“is-a”关系，它是独立的实体。

闭包和回调

        闭包是一个可调用的对象，它保留了来自它被创建时所在的作用域的信息。内部类就是面向对象的闭包，因为它不仅包含了外围类对象的每一条信息，而且自动持有着对整个外围类的引用。

    有人认为Java应该拥有某种指针机制，以此来支持回调。但Java出于谨慎，没有向语言中引入指针。

||| 回调的概念：对象获得某种信息，在之后的某段时间，凭借信息调用回原始的对象。

        内部类为闭包通过了一个解决方案，这种方案比指针更加灵活和安全：

interface Incrementable {
    void increment();
}

// 简单地实现Incrementable接口
class Callee1 implements Incrementable {
    private int i = 0;

    @Override
    public void increment() {
        i++;
        System.out.println("Callee1类的方法increment()，i = " + i);
    }
}

class MyIncrement {
    public void increment() {
        System.out.println("这个increment()方法来自于其他的类（MyIncrement）");
    }

    static void f(MyIncrement mi) {
        mi.increment();
    }
}

// 由于MyIncrement已经实现了一个increment()方法
// 所以若需要通过其他方式实现increment()方法，就必须使用内部类
class Callee2 extends MyIncrement {
    private int i = 0;

    @Override
    public void increment() {
        super.increment();
        i++;
        System.out.println("Callee2类的方法increment()，i = " + i);
    }

    private class Closure implements Incrementable {
        @Override
        public void increment() {
            // 此处需要指定调用外围类的方法，否则会无限递归
            Callee2.this.increment();
        }
    }

    Incrementable getCallbackReference() {
        return new Closure();
    }
}

class Caller {
    private Incrementable callbackReference;

    Caller(Incrementable cbh) {
        callbackReference = cbh;
    }

    void go() {
        callbackReference.increment();
    }
}

public class Callbacks {
    public static void main(String[] args) {
        Callee1 c1 = new Callee1();
        Callee2 c2 = new Callee2();

        MyIncrement.f(c2);
        System.out.println();

        Caller caller1 = new Caller(c1);
        Caller caller2 = new Caller(c2.getCallbackReference());

        caller1.go();
        caller1.go();
        System.out.println();
        caller2.go();
        caller2.go();
    }
}

        程序执行的结果是：

        上述程序显示了在外围类中实现接口和在内部类中实现接口的区别。

        就代码而言，Callee1显然更加简单。Callee2继承自MyIncrement类，基类中已经存在一个increment()方法，但这个increment()和Increment接口期望的不一样。而因为MyIncrement已经被Callee2继承，此时increment()无法再为满足Increment接口的需要而重写。这时就需要内部类提供单独的实现。

    Callee2与外部建立联系离不开Incrementable，这里体现了接口支持的接口与实现的完全分离。

        注意：Closure和Caller都实现了回调这一功能，它们都通过保存或使用一个安全的引用来限制这种回调的风险。

||| 回调的价值在于其的灵活性，它允许我们在运行时动态地决定调用哪些方法。

---

内部类和控制框架

        应用框架是为了解决某一特定类型的问题而设计的一个或一组类。通过应用框架提供的通用的解决方案，我们可以在重写方法时通过定制来解决特定的问题。这就是模板方法设计模式的一个例子。

    通过设计方案将变化的事物和不变的事物分离，此时模板方法就是不变的事物，可重写的方法则是变化的事物。

        控制框架是一种特殊类型的应用框架，主要用于满足对事件做出响应这样的需求。通过内部类，可以简化控制框架的创建和使用。

        例如：存在一个框架，其作用是当事件“就绪”时执行相应时间（“就绪”可以指代任何事物，下面的例子中“就绪”指代时间）。现在有一个用于描述控制事件的接口，是一个abstract类，其默认行为是基于时间来执行控制的，它有部分实现：

package controller;

import java.time.Instant;
import java.time.Duration;

public abstract class Event {
    private Instant evenTime;
    protected final Duration delayTime;

    public Event(long millisecondDelay) {
        delayTime = Duration.ofMillis(millisecondDelay);
        start();
    }

    public void start() {
        evenTime = Instant.now().plus(delayTime);
    }

    public boolean ready() {
        return Instant.now().isAfter(evenTime);
    }

    public abstract void action();
}

    上述代码中的action()方法，用来处理所控制的事物。与其有关的信息在继承时实现。

• start()被时间为单独的方法，而没有直接实现在构造器中。这种做法允许我们在事件结束完毕后重启计时器，复用Event对象。
• ready()用于控制action()方法的运行时机，可以在子类中进行重写，使Event可以通过时间之外的要素触发。

        下面编写用于管理和触发事件的真正的控制框架。

package controller;

import java.util.ArrayList;
import java.util.List;

// 用于控制系统的可复用框架
public class Controller {
    // Event对象被保存在一个List类型的集合对象中（读作List of Event）
    private List eventList = new ArrayList<>();

    public void addEvent(Event c) {
        eventList.add(c); // add()用于将一个Event添加到List的末尾
    }

    public void run() {
        while (eventList.size() > 0) // size()用于得到列表中的实体数量
            for (Event e : new ArrayList<>(eventList))
                // 此处创建了一个副本，这样在选择列表中的元素时就不需要改动列表了
                if (e.ready()) {
                    System.out.println(e);
                    e.action();
                    eventList.remove(e); // 用于移除指定的Event
                }
    }
}

        这段代码设计的一个关键在于，我们不知道也不需要知道Event到底是用来做什么的，换句话说，这种设计“将变化的事物与保持不变的事物分离开来”。

        接下来就是内部类登场的时候了，内部类允许：

1. 控制框架的整个实现是在一个单独的类中完成的，这封装了其实现的所有特点。而内部类用来表达解决问题所需的不同的action()。
2. 内部类简化了上述的这种需求，因为它可以轻松访问外围类的任何成员。

        下方出现的应用框架ManyController就继承自Controller：

import controller.Controller;
import controller.Event;

public class ManyControlls extends Controller {
    // 控制灯
    private boolean light = false;

    public class LightOn extends Event {
        public LightOn(long delayTime) {
            super(delayTime);
        }

        @Override
        public void action() {
            // 此处处理硬件控制代码
            light = true;
        }

        @Override
        public String toString() {
            return "灯开了";
        }
    }

    public class LightOff extends Event {
        public LightOff(long delayTime) {
            super(delayTime);
        }

        @Override
        public void action() {
            light = false;
        }

        @Override
        public String toString() {
            return "灯关了";
        }
    }

    // 控制闹铃
    public class Bell extends Event {
        public Bell(long delayTime) {
            super(delayTime);
        }

        // action（）的一个例子，向事件中插入一个新的相同事件
        @Override
        public void action() {
            addEvent(new Bell(delayTime.toMillis()));
        }

        @Override
        public String toString() {
            return "闹铃响了";
        }
    }

    // 重启
    public class Restart extends Event {
        private Event[] eventList;

        public Restart(long delayTime, Event[] eventList) {
            super(delayTime);
            this.eventList = eventList;
            for (Event e : eventList)
                addEvent(e);
        }

        @Override
        public void action() {
            for (Event e : eventList) {
                e.start(); // 重新运行每个事件
                addEvent(e);
            }
            start(); // 重新运行该事件
            addEvent(this);
        }

        @Override
        public String toString() {
            return "重启";
        }
    }

    public static class Terminate extends Event {
        public Terminate(long delayTime) {
            super(delayTime);
        }

        @Override
        public void action() {
            System.exit(0);
        }

        @Override
        public String toString() {
            return "结束";
        }
    }
}

        上述框架中，light属于外围类ManyControlls，但内部类可以无需限定条件或是特殊权限，即可直接访问这些字段。

    内部类和多重继承很像：Bell和Restart拥有Event的所有方法，而且看起来也有外围类ManyControlls的所有方法。

        接下来就需要配置系统了：创建一个ManyControlls对象，在加入不同的Event对象，这就是命令设计模式的一个例子，eventList中的每一个对象都被封装为对象的请求：

import controller.Event;

public class ManyController {
    public static void main(String[] args) {
        ManyControlls ms = new ManyControlls();

        // 也可以从文本文件中解析配置信息
        ms.addEvent(ms.new Bell(900));
        Event[] eventList = {
                ms.new LightOn(900),
                ms.new LightOff(900),
        };

        ms.addEvent(ms.new Restart(2000, eventList));
        ms.addEvent(new ManyControlls.Terminate(5000));
        ms.run();
    }
}

        程序执行的结果如下：

    若从文件中读取事件，而不是通过编码，会更加灵活。

继承内部类

        内部类的构造器需要依附于一个指向其包围类的对象的引用，这使得继承内部类变得更加复杂了。因为外部类的引用必须初始化，但子类中不存在默认的对象允许内部类进行依附。所以需要使用特殊的语法指出这种关联：

class WithInner {
    class Inner {
    }
}

public class InheritInner extends WithInner.Inner {
    // InheritInner() {} // 无法使用这种方式进行初始化，编译器认为没有可以依附的复习
    InheritInner(WithInner wi) {
        wi.super(); // 提供一个必须的引用
    }

    public static void main(String[] args) {
        WithInner wi = new WithInner();
        InheritInner ii = new InheritInner(wi);
    }
}

        在这里，InheritInner类继承了一个内部类。对这个子类而言，默认构造器是行不通的。而如果只传递一个外围类的参数WithInner wi，也还是不够。必须在构造器中使用如下的语法：

外围类的引用.super(); // 提供必须的引用

内部类的重写（并不能）

        已知，若一个类继承了一个基类，这个类就应该可以重写基类中的方法。那么若继承了一个包含内部类的外围类，我们是否可以“重写”整个内部类了？

    不过，把内部类当作外围类中的其他方法一样进行重写，并没有什么实际意义。

// 内部类不能像方法一样进行重写

class Egg {
    private Yolk y;

    protected class Yolk {
        public Yolk() {
            System.out.println("Egg.Yolk()");
        }
    }

    Egg() {
        System.out.println("New Egg()");
        y = new Yolk();
    }
}

public class BigEgg extends Egg {
    public class Yolk {
        public Yolk() {
            System.out.println("BigEgg.Yolk()");
        }
    }

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

        程序执行的结果是：

        虽然上述代码的main()函数创建的是一个BigEgg的引用，但是实际输出的Yolk()方法确实属于基类Egg的。

        从中可以得出一个结论：当继承外围类时，内部类不会有任何额外的特殊之处（与其他外围类的方法相比）。内部类是完全独立的实体，有属于自己的命名空间。

        不过可以显式地继承一个内部类：

class Egg2 {
    protected class Yolk {
        public Yolk() {
            System.out.println("Egg2.Yolk() 构造器");
        }

        public void f() {
            System.out.println("Egg2.Yolk.f() 方法");
        }
    }

    private Yolk y = new Yolk();

    Egg2() {
        System.out.println("Egg2() 构造器");
    }

    public void insertYolk(Yolk yy) {
        y = yy;
    }

    public void g() {
        y.f();
    }
}

public class BigEgg2 extends Egg2 {
    public class Yolk extends Egg2.Yolk {
        public Yolk() {
            System.out.println("BigEgg2.Yolk 构造器");
        }

        @Override
        public void f() {
            System.out.println("BigEgg2.Yolk.f() 方法");
        }
    }

    public BigEgg2() {
        insertYolk(new Yolk());
    }

    public static void main(String[] args) {
        Egg2 e2 = new BigEgg2();
        e2.g();
    }
}

        程序执行的结果如下：

        insertYolk()方法允许BigEgg2将其的Yolk对象向上转型为Egg2中的y引用。所以g()调用的y.f()是f()的重写版本。另外，对Egg2.Yolk()的第二次调用，是BiggEgg2.Yolk调用基类构造器时触发的。

局部内部类

        局部内部类不是外围类的组成部分，因此不能对它使用访问权限修饰符。但它可以访问当前代码块中的常量，以及外围类的所有成员。

        通过一个例子比较局部内部类和匿名内部类的区别：

interface Counter {
    int next();
}

public class LocalInnerClass {
    private int count = 0;

    Counter getCounter1(final String name) {
        // 这是一个局部内部类：
        class LocalCounter implements Counter {
            LocalCounter() {
                // 局部内部类可以有一个构造器
                System.out.println("LocalCounter()");
            }

            @Override
            public int next() {
                System.out.print(name); // 可以访问局部的final变量
                return count++;
            }
        }

        return new LocalCounter();
    }

    // 这是有同样功能的一个匿名内部类：
    Counter getCounter2(final String name) {
        return new Counter() {
            // 匿名内部类没有显式的构造器
            // 只有实例初始化
            {
                System.out.println("Counter()");
            }

            @Override
            public int next() {
                System.out.print(name); // 也可以访问局部的final变量
                return count++;
            }
        };
    }

    public static void main(String[] args) {
        LocalInnerClass lic = new LocalInnerClass();
        Counter c1 = lic.getCounter1("局部内部类"),
                c2 = lic.getCounter2("匿名内部类");

        System.out.println();
        for (int i = 0; i < 5; i++)
            System.out.println(c1.next());

        System.out.println();
        for (int i = 0; i < 5; i++)
            System.out.println(c2.next());
    }
}

        程序执行的结果是：

        上述的局部内部类和匿名内部类有相同的行为和功能。二者有这样的一些区别：

局部内部类	匿名内部类
名字无法在方法外使用。	是匿名的。
允许构造器的定义，及其的重载。	只能进行实例初始化。
允许我们创建多个对象。	通常用于返回该类的一个实例。

内部类标识符

        在加载时，每个类文件都会产生一个叫做Class对象的元类（meta-class）。内部类当然也会生成.class文件，并且包含其Class对象所需的信息。这种文件/类的命名遵循一个公式：外围类的名字 + $ + 内部类的名字。例如：

        若内部类是匿名的，编译器会使用数字作为内部标识符。若内部类嵌套在其他内部类之内，它们的名字会被附加到其外围标识符和$之后。