第十章 - 内部类

叁歲伎倆 2022-05-21 03:22 231阅读 0赞

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

## 创建内部类 ##

创建内部类的方式就是如同你想的一样，把类的定义置于外围类的里面

public class Parcel1 {
      class Contents {
        private int i = 11;
        public int value() {
          return i;
        }
      }
      class Destination {
        private String label;
        Destination(String whereTo) {
          label = whereTo;
        }
        String readLabel() {
          return label;
        }
      }	
    
      public void ship(String dest) {
        Contents c = new Contents();
        Destination d = new Destination(dest);
        System.out.println(d.readLabel());
      }
      public static void main(String[] args) {
        Parcel1 p = new Parcel1();
        p.ship("Tasmania");
      }
    }

![70][]

当我们在ship（）方法里面使用内部类的时候，与普通类没什么区别，在这里实际的区别只是内部类的名字嵌套在Parcel1里面的。不过下面将会看到这不是唯一的区别。

比如外围类有一个方法，该方法返回一个指向内部类的引用，就像在to（）和content（）方法中看到的那样

public class Parcel2 {
        class Contents {
            private int i = 11;
    
            public int value() {
                return i;
            }
        }
    
        class Destination {
            private String label;
    
            Destination(String whereTo) {
                label = whereTo;
            }
    
            String readLabel() {
                return label;
            }
        }
    
        public Destination to(String s) {
            return new Destination(s);
        }
    
        public Contents contents() {
            return new Contents();
        }
    
        public void ship(String dest) {
            Contents c = contents();
            Destination d = to(dest);
            System.out.println(d.readLabel());
        }
    
        public static void main(String[] args) {
            Parcel2 p = new Parcel2();
            p.ship("Tasmania");
            Parcel2 q = new Parcel2();
            Contents c = q.contents();
            Destination d = q.to("Borneo");
        }
    }

如果想从外围类的非静态方法之外的任意位置创建某个内部类的对象，那么必须指明这个对象的类型。

## 链接到外部类 ##

当生成一个内部类的对象时，此对象与制造他的外围类对象之间就有了一种联系，所以他能访问外围对象的所有成员，而不需要任何条件，此外内部类还有外围类的所有元素的访问权（包括private）

interface Selector {
        boolean end();
    
        Object current();
    
        void next();
    }
    
    public class Sequence {
        private Object[] items;
        private int next = 0;
    
        public Sequence(int size) {
            items = new Object[size];
        }
    
        public void add(Object x) {
            if (next < items.length)
                items[next++] = x;
        }
    
        private class SequenceSelector implements Selector {
            private int i = 0;
    
            public boolean end() {
                return i == items.length;
            }
    
            public Object current() {
                return items[i];
            }
    
            public void next() {
                if (i < items.length) i++;
            }
        }
    
        public Selector selector() {
            return new SequenceSelector();
        }
    
        public static void main(String[] args) {
            Sequence sequence = new Sequence(10);
            for (int i = 0; i < 10; i++)
                sequence.add(Integer.toString(i));
    
            Selector selector = sequence.selector();
            while (!selector.end()) {
                System.out.print(selector.current() + " ");
                selector.next();
            }
        }
    }

![70 1][]

## 使用.this 和 .new ##

如果你要生成外部类对象的引用，可以使用外部类的名字后面紧跟原点和this，这样产生的引用自动的具有正确的类型

public class DotThis {
        void f() {
            System.out.println("DotThis.f()");
        }
    
        public class Inner {
            public DotThis outer() {
                return DotThis.this;
                // A plain "this" would be Inner's "this"
            }
        }
    
        public Inner inner() {
            return new Inner();
        }
    
        public static void main(String[] args) {
            DotThis dt = new DotThis();
            Inner dti = dt.inner();
            dti.outer().f();
        }
    }

![70 2][]

有时你可能要想要告知某些其他对象，去创建某个内部的对象，就需要使用.new 语法，就像下面例子

public class DotNew {
        public class Inner {
            public void a (){
                System.out.println("Inner.a()");
            }
        }
    
        public static void main(String[] args) {
            DotNew dn = new DotNew();
            Inner dni = dn.new Inner();
            dni.a();
        }
    }

![70 3][]

在拥有外部类对象之前是不能创建内部类对象的，但是如果创建的是静态内部类，那么就不需要外部类对象的引用了

public class DotNew {
        public static class Inner {
            public void a (){
                System.out.println("Inner.a()");
            }
        }
    
        public static void main(String[] args) {
            Inner dni = new Inner();
            dni.a();
        }
    }

![70 4][]

现在可以将Parcel1改进下了

public class Parcel1 {
      class Contents {
        private int i = 11;
        public int value() {
          return i;
        }
      }
      class Destination {
        private String label;
        Destination(String whereTo) {
          label = whereTo;
        }
        String readLabel() {
          return label;
        }
      }
    
      public static void main(String[] args) {
        Parcel1 p = new Parcel1();
        System.out.println(p.new Destination("Tasmania").readLabel());
      }
    }

![70 5][]

## 内部类与向上转型 ##

当将内部类向上转型为基类，尤其是转向为一个接口的时候，内部类就有了用武之地

public interface Destination {
        String readLabel();
    }

public interface Contents {
        int value();
    }

现在Contents和Destination表示客户端程序员可用的接口

当去得来一个指向基类或接口的引用时，甚至可能无法找出它确切的类型，看下面的例子

class Parcel4 {
    
        private class PContents implements Contents {
            private int i = 11;
            public int value() {
                return i;
            }
        }
    
        protected class PDestination implements Destination {
            private String label;
    
            private PDestination(String whereTo) {
                label = whereTo;
            }
            public String readLabel() {
                return label;
            }
        }
    
        public Destination destination(String s) {
            return new PDestination(s);
        }
    
        public Contents contents() {
            return new PContents();
        }
    }
    
    public class TestParcel {
        public static void main(String[] args) {
            Parcel4 p = new Parcel4();
            Contents c = p.contents();
            Destination d = p.destination("Tasmania");
        }
    }

private内部类，给类的设计者提供了一种途径，通过这种方式可以完全阻止任何依赖于类型的编码，并且完全隐藏了 实现的细节。

外部类是可以方位内部类的private元素的

## 方法和作用域的内部类 ##

我们可以在一个方法里面或者任意的作用域内定义内部类，这么做有两个理由

1. 如前所示，你实现了某类型的接口，于是可以创建并返回对其的引用

2.你要解决一个复杂的问题，想创建一个类来辅助你的解决方案，但是又不想这个类是公共可用的

下面的例子展示在方法的作用域内创建一个完整的类，这叫做局部内部类

public class Parcel5 {
    
        public Destination destination(String s) {
    
            class PDestination implements Destination {
                private String label;
    
                private PDestination(String whereTo) {
                    label = whereTo;
                }
    
                public String readLabel() {
                    return label;
                }
            }
            return new PDestination(s);
        }
    
        public static void main(String[] args) {
            Parcel5 p = new Parcel5();
            Destination d = p.destination("Tasmania");
        }
    }

下面的列子展示如何在任何的作用域内嵌入一个内部类

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();
        }
    }

## 匿名内部类 ##

下面的例子看起来有点奇怪

public class Parcel7 {
        public Contents contents() {
            return new Contents() { // Insert a class definition
                private int i = 11;
    
                public int value() {
                    return i;
                }
            }; // Semicolon required in this case
        }
    
        public static void main(String[] args) {
            Parcel7 p = new Parcel7();
            Contents c = p.contents();
        }
    }

contents（）方法将返回值的生成与表示这个返回值的类的定义结合在一起！另外这个类是匿名的，没有名字。上述匿名类的语法是下述形式的简化形式。

public class Parcel7b {
    
        class MyContents implements Contents {
            private int i = 11;
    
            public int value() {
                return i;
            }
        }
    
        public Contents contents() {
            return new MyContents();
        }
    
        public static void main(String[] args) {
            Parcel7b p = new Parcel7b();
            Contents c = p.contents();
        }
    }

这个匿名内部类，使用了默认的构造器来生成Contents，下面的代码展示的是，如果你的基类需要一个有参数的构造器，应该怎么办

public class Parcel8 {
    
        public Wrapping wrapping(int x) {
            return new Wrapping(x) {
                public int value() {
                    return super.value() * 47;
                }
            };
        }
    
        public static void main(String[] args) {
            Parcel8 p = new Parcel8();
            Wrapping w = p.wrapping(10);
        }
    }

在匿名类中定义字段是，还能够对其进行初始化操作

public class Parcel9 {
    
        public Destination destination(final String dest) {
            return new Destination() {
                private String label = dest;
    
                public String readLabel() {
                    return label;
                }
            };
        }
    
        public static void main(String[] args) {
            Parcel9 p = new Parcel9();
            Destination d = p.destination("Tasmania");
        }
    }

如果定义一个匿名内部类，并且希望她使用一个其外部定义的对象，那么编译器会要求其参数是final的就像destination（）中那样的。

因为匿名类是没有名字的，所有没有构造器，但通过实例初始化，能够达到构造器的效果

abstract class Base {
        public Base(int i) {
            System.out.println("Base constructor, i = " + i);
        }
    
        public abstract void f();
    }
    
    public class AnonymousConstructor {
    
        public static Base getBase(int i) {
            return new Base(i) {
                {
                    System.out.println("Inside instance initializer");
                }
    
                public void f() {
                    System.out.println("In anonymous f()");
                }
            };
        }
    
        public static void main(String[] args) {
            Base base = getBase(47);
            base.f();
        }
    }

![70 6][]

下例是带实例化的parcel形式

public class Parcel10 {
    
        public Destination destination(final String dest, final float price) {
            return new Destination() {
                private int cost;
    
                {
                    cost = Math.round(price);
                    if (cost > 100)
                        System.out.println("Over budget!");
                }
    
                private String label = dest;
    
                public String readLabel() {
                    return label;
                }
            };
        }
    
        public static void main(String[] args) {
            Parcel10 p = new Parcel10();
            Destination d = p.destination("Tasmania", 101.395F);
        }
    }

![70 7][]

## 再访工厂方法 ##

interface Service {
        void method1();
    
        void method2();
    }
    
    interface ServiceFactory {
        Service getService();
    }
    
    class Implementation1 implements Service {
        private Implementation1() {
        }
    
        public void method1() {
            System.out.println("Implementation1 method1");
        }
    
        public void method2() {
            System.out.println("Implementation1 method2");
        }
    
        public static ServiceFactory factory =
                new ServiceFactory() {
                    public Service getService() {
                        return new Implementation1();
                    }
                };
    }
    
    class Implementation2 implements Service {
        private Implementation2() {
        }
    
        public void method1() {
            System.out.println("Implementation2 method1");
        }
    
        public void method2() {
            System.out.println("Implementation2 method2");
        }
    
        public static ServiceFactory factory =
                new ServiceFactory() {
                    public Service getService() {
                        return new Implementation2();
                    }
                };
    }
    
    public class Factories {
        public static void serviceConsumer(ServiceFactory fact) {
            Service s = fact.getService();
            s.method1();
            s.method2();
        }
    
        public static void main(String[] args) {
            serviceConsumer(Implementation1.factory);
            serviceConsumer(Implementation2.factory);
        }
    }

![70 8][]

前面的Games例子也可以通过匿名内部类来改进

interface Game { boolean move(); }
    interface GameFactory { Game getGame(); }
    
    class Checkers implements Game {
      private Checkers() {}
      private int moves = 0;
      private static final int MOVES = 3;
      public boolean move() {
        System.out.println("Checkers move " + moves);
        return ++moves != MOVES;
      }
      public static GameFactory factory = new GameFactory() {
        public Game getGame() {
          return new Checkers();
        }
      };
    }	
    
    class Chess implements Game {
      private Chess() {}
      private int moves = 0;
      private static final int MOVES = 4;
      public boolean move() {
        System.out.println("Chess move " + moves);
        return ++moves != MOVES;
      }
      public static GameFactory factory = new GameFactory() {
        public Game getGame() { return new Chess(); }
      };
    }	
    
    public class Games {
      public static void playGame(GameFactory factory) {
        Game s = factory.getGame();
        while(s.move())
          ;
      }
      public static void main(String[] args) {
        playGame(Checkers.factory);
        playGame(Chess.factory);
      }
    }

## 嵌套类 ##

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

1）要创建嵌套类对象，并不需要外围类对象。

2）不能从嵌套类的对象中访问非静态的外围类对象。

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

public class Parcel11 {
        private static class ParcelContents implements Contents {
            private int i = 11;
    
            public int value() {
                return i;
            }
        }
    
        protected static class ParcelDestination implements Destination {
            private String label;
    
            private ParcelDestination(String whereTo) {
    
                label = whereTo;
            }
    
            public String readLabel() {
                return label;
            }
    
            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");
        }
    }

## 接口内部的类 ##

正常情况下，不能再接口内部放置任何代码，但是嵌套类可以作为接口的一部分，放在接口中的任何类都是自动的是public和staic的，因为类是static的。就像下面这样

public interface ClassInInterface {
        void howdy();
    
        class Test implements ClassInInterface {
            public void howdy() {
                System.out.println("Howdy!");
            }
    
            public static void main(String[] args) {
                new Test().howdy();
            }
        }
    }

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

一个内部类被嵌套多少层不重要

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();
        }
    }

## 为什么需要内部类 ##

内部类必须要回答一个问题是：如果只是需要一个对接口的引用，为什么不通过外围类实现那个接口呢？答案是：如果这能满足需求，那么就应该这么做。那么内部类实现一个接口跟外围类实现一个接口有什么区别呢？答案是：后者不是总能享用到接口带来的方便，有时需要用到接口的实现。所以内部类最吸引人的原因是：每个内部类都能独立地继承自一个（接口的）实现，所以无论外围类是否已经继承了某个（接口的）实现，对于内部类没有影响。

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

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());
        }
    }

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

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());
        }
    }

## 闭包与回调 ##

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

Java最引人争议的问题之一就是，人们认为java应该包含某种类似指针的机制，以允许回调，但是java更小心仔细，所以没有在语言中包含指针，通过内部类提供的闭包功能是优良的解决方案，它比指针更灵活，更安全。

interface Incrementable {
        void increment();
    }
    
    class MyIncrement {
        public void increment() {
            System.out.println("Other operation");
        }
    
        static void f(MyIncrement mi) {
            mi.increment();
        }
    }
    
    class Callee1 implements Incrementable {
        private int i = 0;
    
        public void increment() {
            i++;
            System.out.println(i);
        }
    }
    
    class Callee2 extends MyIncrement {
        private int i = 0;
    
        public void increment() {
            super.increment();
            i++;
            System.out.println(i);
        }
    
        private class Closure implements Incrementable {
            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);
            Caller caller1 = new Caller(c1);
            Caller caller2 = new Caller(c2.getCallbackReference());
            caller1.go();
            caller1.go();
            caller2.go();
            caller2.go();
        }
    }

![70 9][]

## 内部类的继承 ##

因为内部类的构造器必须连接到指向其外围类兑现的引用，所以继承内部类的时候，事情会变的复杂，问题在于，那个指向外围类对象的“秘密的”引用必须被初始化，而在导出类中不在存在可连接的默认对象，要解决这个问题，就必须使用特殊的语法来明确说清他们之间的关联

class WithInner {
        class Inner {
        }
    }
    
    public class InheritInner extends WithInner.Inner {
        //! InheritInner() {} // Won't compile
        InheritInner(WithInner wi) {
            wi.super();
        }
    
        public static void main(String[] args) {
            WithInner wi = new WithInner();
            InheritInner ii = new InheritInner(wi);
        }
    }

enclosingClassReference.super();可以看到，InheritInner只能继承自内部类，而不是外围类，但是要生成一个构造器，默认的构造器不算好，而且不能只是传递一个指向外围类的对象的引用，此外，必须在构造器内使用如下语法：enclosingClassReference.super();

## 内部类可以被覆盖吗 ##

如果创建了一个内部类，然后继承其外围类并重新定义内部类时，会发生什么呢？也就是内部类可以被覆盖么

class Egg {
        private Yolk y;
    
        protected class Yolk {
            public Yolk() {
                System.out.println("Egg.Yolk()");
            }
        }
    
        public 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();
        }
    }

![70 10][]

默认的构造器是编译器自动生成的，这里是调用基类的默认构造器。你可能认为既然创建了GigEgg的对象，那么所使用的应该是覆盖后的Yolk版本，但是从输出结果看，并不是这样的

这个例子说明，当继承了某个外围类的时候，内部类并没有发生什么特别的变化，这两个内部类时完全独立的实体，各自在自己的命名空间内，当然，明确的继承某个内部类也是可以的

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();
    
        public Egg2() {
            System.out.println("New 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()");
            }
    
            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();
        }
    }

![70 11][]

## 局部内部类 ##

前面提到过，可以在代码块创建内部类，典型的方式是在一个方法体的里面创建，局部内部类不能有访问符，因为它不是外围类的一部分，但是可以访问当前代码块内的常量以及此外围类的所有成员。

## 内部类标识符 ##

每个类会产生一个class文件，内部类也会有class文件规则：外围类的名字加上$再加上内部类的名字

[70]: /images/20220521/6bdca7a0f61f4805a0427c3f616864fd.png
[70 1]: /images/20220521/5279eb91c34849279f92ac5e79b53419.png
[70 2]: /images/20220521/2e3177235f684d48b816dda9dbef5d14.png
[70 3]: /images/20220521/9f746080c55f4ae28e9a2f8a314f373a.png
[70 4]: /images/20220521/0f0e4141e655499386c0170a0b8522fb.png
[70 5]: /images/20220521/a6eb336369874cb09f182dc826771e2a.png
[70 6]: /images/20220521/b6a00050be53413d84f032d16085a728.png
[70 7]: /images/20220521/bed9953ff1a7459aac41229d1853d929.png
[70 8]: /images/20220521/15f8472ba7a242e1b4cd25d4e141e931.png
[70 9]: /images/20220521/67db81b2b7274cbaa2569d3a82127f3f.png
[70 10]: /images/20220521/1b4c3e3efb854044b7039729f262afd1.png
[70 11]: /images/20220521/a2f5c4be9ab54bbd92fc043e653b3af6.png