Think in Java 5th/On Java 8阅读整理:内部类(篇3:嵌套类、为什么需要内部类part 1)

我会带着你远行 2024-04-17 21:52 3阅读 0赞

此文章为本系列的第三篇,继续内部类部分,GO!

## [书籍电子版传送门][Link 1] ##

无底色文字:原文章  
有底色文字:个人备注  
代码:原文代码+个人测试代码+个人注释

--------------------

# 嵌套类 #

如果不需要内部类对象与其外围类对象之间有联系，那么可以将内部类声明为 static，这通常称为嵌套类。想要理解 static 应用于内部类时的含义，就必须记住，普通的内部类对象隐式地保存了一个引用，指向创建它的外围类对象。然而，当内部类是 static 的时，就不是这样了。嵌套类意味着：

1.  要创建嵌套类的对象，并不需要其外围类的对象。
2.  不能从嵌套类的对象中访问非静态的外围类对象。

嵌套类与普通的内部类还有一个区别。普通内部类的字段与方法，只能放在类的外部层次上，所以普通的内部类不能有 static 数据和 static 字段，也不能包含嵌套类。但是嵌套类可以包含所有这些东西：

// innerclasses/Parcel11.java
    // Nested classes (static inner classes)
    public class Parcel11 { 
        private static class ParcelContents implements Contents { 
            private int i = 11;
            @Override
            public int value() {  return i; }
        }
        protected static final class ParcelDestination
                implements Destination { 
            private String label;
            private ParcelDestination(String whereTo) { 
                label = whereTo;
            }
            @Override
            public String readLabel() {  return label; }
            // Nested classes can contain other static elements:
            public static void f() { }
            static int x = 10;
            static class AnotherLevel { 
                public static void f() { }
                static int x = 10;
            }
        }
        public static Destination destination(String s) { 
            return new ParcelDestination(s);
        }
        public static Contents contents() { 
            return new ParcelContents();
        }
        public static void main(String[] args) { 
            Contents c = contents();
            Destination d = destination("Tasmania");
        }
    }

在 main() 中，没有任何 Parcel11 的对象是必需的；而是使用选取 static 成员的普通语法来调用方法-这些方法返回对 Contents 和 Destination 的引用。

就像你在本章前面看到的那样，在一个普通的（非 static）内部类中，通过一个特殊的 this 引用可以链接到其外围类对象。嵌套类就没有这个特殊的 this 引用，这使得它类似于一个 static 方法。

以上讲了嵌套类（静态内部类），在上一篇已经超前测试过这种内部类了，还是比较好理解的，最后也说了类似于static方法

### 接口内部的类 ###

嵌套类可以作为接口的一部分。你放到接口中的任何类都自动地是 public 和 static 的。因为类是 static 的，只是将嵌套类置于接口的命名空间内，这并不违反接口的规则。你甚至可以在内部类中实现其外围接口，就像下面这样：

输出为：

Howdy!

如果你想要创建某些公共代码，使得它们可以被某个接口的所有不同实现所共用，那么使用接口内部的嵌套类会显得很方便。

以下为测试以上最后一段话，一个类实现接口后能使用其静态内部类。

// innerclasses/ClassInInterface.java
    // {java ClassInInterface$Test}
    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();
            }
        }
    }
    
    class Test2 implements ClassInInterface{ 
        @Override
        public void howdy() { 
            Test test = new Test();
            test.howdy();
            System.out.println("test2");
        }
    
        public static void main(String[] args) { 
            Test2 test2 = new Test2();
            test2.howdy();
        }
    }

输出结果：

Howdy!
    test2

我曾在本书中建议过，在每个类中都写一个 main() 方法，用来测试这个类。这样做有一个缺点，那就是必须带着那些已编译过的额外代码。如果这对你是个麻烦，那就可以使用嵌套类来放置测试代码。

// innerclasses/TestBed.java
    // Putting test code in a nested class
    // {java TestBed$Tester}
    public class TestBed { 
        public void f() {  System.out.println("f()"); }
        public static class Tester { 
            public static void main(String[] args) { 
                TestBed t = new TestBed();
                t.f();
            }
        }
    }

输出为：

f()

这生成了一个独立的类 TestBed$Tester（要运行这个程序，执行 java TestBed$Tester，在 Unix/Linux 系统中需要转义 $）。你可以使用这个类测试，但是不必在发布的 产品中包含它，可以在打包产品前删除 TestBed$Tester.class。

以上讲了可以用嵌套类代替直接写main方法来测试，好处在于这个嵌套类会生成独立的class文件，最后发布项目前可以删掉减少不必要的代码以及节省空间。

### 从多层嵌套类中访问外部类的成员 ###

一个内部类被嵌套多少层并不重要——它能透明地访问所有它所嵌入的外围类的所有成员，如下所示：

// innerclasses/MultiNestingAccess.java
    // Nested classes can access all members of all
    // levels of the classes they are nested within
    class MNA { 
        private void f() { }
        class A { 
            private void g() { }
            public class B { 
                void h() { 
                    g();
                    f();
                }
            }
        }
    }
    public class MultiNestingAccess { 
        public static void main(String[] args) { 
            MNA mna = new MNA();
            MNA.A mnaa = mna.new A();
            MNA.A.B mnaab = mnaa.new B();
            mnaab.h();
        }
    }

可以看到在 MNA.A.B 中，调用方法 g() 和 f() 不需要任何条件（即使它们被定义为 private）。这个例子同时展示了如何从不同的类里创建多层嵌套的内部类对象的基本语法。".new"语法能产生正确的作用域，所以不必在调用构造器时限定类名。

多层嵌套类中使用外部或者外部的外部资源时，可以直接调用，看例子十分清楚

--------------------

# 为什么需要内部类 #

至此，我们已经看到了许多描述内部类的语法和语义，但是这并不能同答“为什么需要内部类”这个问题。那么，Java 设计者们为什么会如此费心地增加这项基本的语言特性呢？

一般说来，内部类继承自某个类或实现某个接口，内部类的代码操作创建它的外围类的对象。所以可以认为内部类提供了某种进入其外围类的窗口。

内部类必须要回答的一个问题是：如果只是需要一个对接口的引用，为什么不通过外围类实现那个接口呢？答案是：“如果这能满足需求，那么就应该这样做。”那么内部类实现一个接口与外围类实现这个接口有什么区别呢？答案是：后者不是总能享用到接口带来的方便，有时需要用到接口的实现。所以，使用内部类最吸引人的原因是：

**每个内部类都能独立地继承自一个（接口的）实现，所以无论外围类是否已经继承了某个（接口的）实现，对于内部类都没有影响。**

如果没有内部类提供的、可以继承多个具体的或抽象的类的能力，一些设计与编程问题就很难解决。从这个角度看，内部类使得多重继承的解决方案变得完整。接口解决了部分问题，而内部类有效地实现了“多重继承”。也就是说，内部类允许继承多个非接口类型（译注：类或抽象类）。

为了看到更多的细节，让我们考虑这样一种情形：即必须在一个类中以某种方式实现两个接口。由于接口的灵活性，你有两种选择；使用单一类，或者使用内部类：

// innerclasses/mui/MultiInterfaces.java
    // Two ways a class can implement multiple interfaces
    // {java innerclasses.mui.MultiInterfaces}
    package innerclasses.mui;
    interface A { }
    interface B { }
    class X implements A, B { }
    class Y implements A { 
        B makeB() { 
            // Anonymous inner class:
            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());
        }
    }

当然，这里假设在两种方式下的代码结构都确实有逻辑意义。然而遇到问题的时候，通常问题本身就能给出某些指引，告诉你是应该使用单一类，还是使用内部类。但如果没有任何其他限制，从实现的观点来看，前面的例子并没有什么区别，它们都能正常运作。

如果拥有的是抽象的类或具体的类，而不是接口，那就只能使用内部类才能实现多重继承：

// innerclasses/MultiImplementation.java
    // For concrete or abstract classes, inner classes
    // produce "multiple implementation inheritance"
    // {java innerclasses.MultiImplementation}
    package innerclasses;
    
    class D { }
    
    abstract class E { }
    
    class Z extends D { 
        E makeE() { 
          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.makeE());
        }
    }

如果不需要解决“多重继承”的问题，那么自然可以用别的方式编码，而不需要使用内部类。但如果使用内部类，还可以获得其他一些特性：

1.  内部类可以有多个实例，每个实例都有自己的状态信息，并且与其外围类对象的信息相互独立。
2.  在单个外围类中，可以让多个内部类以不同的方式实现同一个接口，或继承同一个类。 稍后就会展示一个这样的例子。
3.  创建内部类对象的时刻并不依赖于外围类对象的创建
4.  内部类并没有令人迷惑的"is-a”关系，它就是一个独立的实体。

举个例子，如果 Sequence.java 不使用内部类，就必须声明"Sequence 是一个 Selector"，对于某个特定的 Sequence 只能有一个 Selector，然而使用内部类很容易就能拥有另一个方法 reverseSelector()，用它来生成一个反方向遍历序列的 Selector，只有内部类才有这种灵活性。

## 闭包与回调 ##

闭包（closure）是一个可调用的对象，它记录了一些信息，这些信息来自于创建它的作用域。通过这个定义，可以看出内部类是面向对象的闭包，因为它不仅包含外围类对象（创建内部类的作用域）的信息，还自动拥有一个指向此外围类对象的引用，在此作用域内，内部类有权操作所有的成员，包括 private 成员。

在 Java 8 之前，生成闭包行为的唯一方式就是内部类。在 Java 8 之后，我们可以使用 lambda 表达式来生成闭包行为，并且语法更加精细和简洁；你将会在 函数式编程 这一章节中学习相关细节。即使应该优先使用 lambda 表达式用于内部类闭包，你依旧会看到那些 Java 8 以前的代码，即使用内部类来表示闭包的方式，所以非常有必要来理解这种形式。

Java 最引人争议的问题之一就是，人们认为 Java 应该包含某种类似指针的机制，以允许回调（callback）。通过回调，对象能够携带一些信息，这些信息允许它在稍后的某个时刻调用初始的对象。稍后将会看到这是一个非常有用的概念。如果回调是通过指针实现的，那么就只能寄希望于程序员不会误用该指针。然而，读者应该已经了解到，Java 更小心仔细，所以没有在语言中包括指针。

通过内部类提供闭包的功能是优良的解决方案，它比指针更灵活、更安全。见下例：

// innerclasses/Callbacks.java
    // Using inner classes for callbacks
    // {java innerclasses.Callbacks}
    package innerclasses;
    interface Incrementable { 
        void increment();
    }
    // Very simple to just implement the interface:
    class Callee1 implements Incrementable { 
        private int i = 0;
        @Override
        public void increment() { 
            i++;
            System.out.println(i);
        }
    }
    class MyIncrement { 
        public void increment() { 
            System.out.println("Other operation");
        }
        static void f(MyIncrement mi) {  mi.increment(); }
    }
    // If your class must implement increment() in
    // some other way, you must use an inner class:
    class Callee2 extends MyIncrement { 
        private int i = 0;
        @Override
        public void increment() { 
            super.increment();
            i++;
            System.out.println(i);
        }
        private class Closure implements Incrementable { 
            @Override
            public void increment() { 
                // Specify outer-class method, otherwise
                // you'll get an infinite recursion:
                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);
            Caller caller1 = new Caller(c1);
            Caller caller2 =
                    new Caller(c2.getCallbackReference());
            caller1.go();
            caller1.go();
            caller2.go();
            caller2.go();
        }
    }

输出为：

Other operation
    1
    1
    2
    Other operation
    2
    Other operation
    3

这个例子进一步展示了外围类实现一个接口与内部类实现此接口之间的区别。就代码而言，Calleel 是更简单的解决方式。Callee2 继承自 MyIncrement，后者已经有了一个不同的 increment() 方法，并且与 Incrementable 接口期望的 increment() 方法完全不相关。所以如果 Callee2 继承了 MyIncrement，就不能为了 Incrementable 的用途而覆盖 increment() 方法，于是只能使用内部类独立地实现 Incrementable，还要注意，当创建了一个内部类时，并没有在外围类的接口中添加东西，也没有修改外围类的接口。

注意，在 Callee2 中除了 getCallbackReference() 以外，其他成员都是 private 的。要想建立与外部世界的任何连接，接口 Incrementable 都是必需的。在这里可以看到，interface 是如何允许接口与接口的实现完全独立的。 内部类 Closure 实现了 Incrementable，以提供一个返回 Callee2 的“钩子”（hook）-而且是一个安全的钩子。无论谁获得此 Incrementable 的引用，都只能调用 increment()，除此之外没有其他功能（不像指针那样，允许你做很多事情）。

Caller 的构造器需要一个 Incrementable 的引用作为参数（虽然可以在任意时刻捕获回调引用），然后在以后的某个时刻，Caller 对象可以使用此引用回调 Callee 类。

回调的价值在于它的灵活性-可以在运行时动态地决定需要调用什么方法。例如，在图形界面实现 GUI 功能的时候，到处都用到回调。

看完以上的代码着实让人觉得头疼，以上这几段话还得反复思考，不是特别理解。个人觉得这节比较关键，讲了为什么会需要使用，这节还没有结束，下篇继续。

[Link 1]: https://lingcoder.gitee.io/onjava8/#/README