第10章-内部类II

Think in java 读书笔记

pikzas

2019.05.05

第十章 内部类

知识点

1.什么是内部类

可以将一个类定义在另一个类的内部

class OuterClass{
    class InnerClass{

    }
}

2.内部类的主要特征是什么

内部类的主要特征是内部类可以随意访问外部类的属性和方法，不论其访问修饰符是什么

public interface Selector {
    boolean end();
    Object current();
    void next();
}

public class Seq {
    private Object[] items;
    private int next = 0;
    public Seq(int size){
        items = new Object[size];
    }
    public void add(Object item){
        if(next < items.length){
            items[next++] = item;
        }
    }

    private class SeqSelector implements Selector{
        private int i = 0;

        @Override
        public boolean end() {
            return i == items.length;
        }

        @Override
        public Object current() {
            return items[i];
        }

        @Override
        public void next() {
            if(i<items.length){
                i++;
            }
        }
    }

    public Selector getSelector(){
        return new SeqSelector();
    }

    public static void main(String[] args) {
        Seq sq = new Seq(10);
        for (int i =0 ; i < sq.items.length ; i++){
            sq.add(Integer.toString(i));
        }
        Selector selector = sq.getSelector(); //此时，外部类对象的引用会被传递给内部类对象
        while (!selector.end()){
            System.out.println(selector.current());
            selector.next();
        }
    }

}

3.适用于内部类的一些特殊语法

.new 由外部类对象新创建内部类对象

class Outer{
    class Inner{}
}

class Demo{
    public static void main(String[] args){
      Outer outer = new Outer();
      Outer.Inner inner = outer.new Inner();
    }
}

.this 在内部类如果想要获取外部类对象的引用

class DotThis{
    void f() {System.out.println("DotThis.f()");}
    class Inner{
        public DotThis getOuterObj(){
            return DotThis.this;
        }
    }

    public Inner getInner(){
        return new Inner();
    }

    public static void main(String[] args){
      DotThis dotThis = new DotThis();
      DotThis.Inner inner = dotThis.getInner();
      System.out.println(inner.getOuterObj().equals(dotThis));  // 输出为true
      inner.getOuterObj().f();  // inner.getOuterObj() 等同于 dotThis

    }
}

.new 语法也可已看出，必须要先有外部类实例，再由这个实例.new 出内部类。（静态内部类除外）

4.内部类与接口的配合使用

内部类实现接口，并将内部类访问限定为private或者protected，从而将实现隐藏在该内部类中。

public interface Dest {
    int value();
}

public class Demo {
    private class DestImp implements Dest{
        @Override
        public int value() {
            return 0;
        }
    }

    public Dest getDest(){
        return new DestImp();
    }
}

public class Test {
    public static void main(String[] args) {
        Demo demo = new Demo();
        Dest dest = demo.getDest();
        dest.value();
    }
}

5.局部内部类

以上看到的内部类都是直接定义在外部类的作用域内，如果让一个内部类定义在外部类的某个方法内部时，这就称作局部内部类。

并且当作用域超出了这个方法的时候，外部是访问不到该类的。

public interface Fruit {
    String desc();
}

public class Test {
    public Fruit getFruit(){
        class Apple implements Fruit{
            @Override
            public String desc() {
                return "i am apple";
            }
        }
        return new Apple();
    }
    //   getFruit方法之外，是访问不到Apple类的
    //   private Fruit fruit = new Apple();
}

6.匿名内部类

上面的局部内部类将Apple的定义和new 创建新对象的语法放在一起就是匿名内部类。如果返回的是具体的类，看起来也就没什么特殊了。

public interface Fruit {
    String desc();
}

public class Test2 {
    public Fruit getFruit(){
        return new Fruit(){
            @Override
            public String desc() {
                return "i am apple";
            }
        };
    }
    public static void main(String[] args) {
        Test2 test2 = new Test2();
        Fruit fruit = test2.getFruit();
        System.out.println(fruit.desc());
    }
}

6.1.匿名内部类可以是具体类,甚至可以对其方法进行override

public class Wrapping {
    private int i;
    public Wrapping(int x){
        this.i = x;
    }
    public int value(){
        return i;
    }
}

public class Outer {
    public Wrapping getItem(int x){
        return new Wrapping(x){
            @Override
            public int value(){
                return super.value() * 47;
            }
        };
    }

    public Wrapping getItem2(int x){
        return new Wrapping(x);
    }

    public static void main(String[] args) {
        Outer outer = new Outer();
        Wrapping wrapping = outer.getItem(10);
        Wrapping wrapping2 = outer.getItem2(10);
        System.out.println(wrapping.value());
        System.out.println(wrapping2.value());
    }
}

------输出结果------
470
10

6.2.对匿名内部类的字段进行初始化

• 使用外部类传入的数据进行初始化，此时该数据必须为final的

public interface SampleInterface {
    int value();
}

public class InitDemo {
    public SampleInterface getSample(final int x){  //此处final必须为final的 可以理解为外部对象指向的数据不能变动，否则内部类对象会很困惑。
        return new SampleInterface() {
            private int i = x;
            @Override
            public int value() {
                return i;
            }
        };
    }
}

• 通过初始化代码块完成类似于构造器的功能

public 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){ //此处的变量不用是final的，因为内部类并没用到i
        return new Base(i){
            {
                System.out.println("inside instance");  // 通过静态代码块可以实现初始化
            }
            public void f(){
                System.out.println("in inner f()");
            }
        };
    }

    public static void main(String[] args) {
        Base base = getBase(47);
        base.f();
    }
}

从上面对于传入内部类的参数是否要加上final的修饰规定是，如果内部类用到了外部传入的那个变量，则需要为final的。

内部类可以拿来扩展类，也可以拿来实现接口，但是不能两个都做到，也只能一次实现一个接口。

7.工厂方法的内部类实现方式

public interface Game {
    boolean move();
}

public interface GameFactory {
    Game getGame();
}

public class Chess implements Game {
    private Chess(){};
    private int moves = 0;
    private static final int MOVES = 4;
    @Override
    public boolean move() {
        System.out.println("Chess moves" + moves);
        return ++moves != MOVES;
    }

    public static GameFactory factory = new GameFactory(){
        public Game getGame(){
            return new Chess();
        }
    };

}

public class Checkers implements Game {
    private Checkers(){}
    private int moves = 0;
    private static final int MOVES = 3;

    @Override
    public boolean move() {
        System.out.println("Checker moves" + moves);
        return ++moves != MOVES;
    }

    public static GameFactory factory = new GameFactory() {
        @Override
        public Game getGame() {
            return new Checkers();
        }
    };
}

public class Test {
    public static void playGame(GameFactory factory) {
        Game game = factory.getGame();
        while(game.move());
    }
    public static void main(String[] args) {
        playGame(Chess.factory);
        playGame(Checkers.factory);
    }
}
-------输出结果----

Chess moves0
Chess moves1
Chess moves2
Chess moves3
Checker moves0
Checker moves1
Checker moves2

8.嵌套类（也成为静态内部类）

前面讲到的内部类的创建都依赖于外部类的对象，如果内部类定义的时候是static的，那么外部对象就不需要了。

同时因为内部类是static的，那么如果想要使用外部类中的属性或者方法，那么那些属性或者方法必须也是static的。

public class Outer {
    private int x = 123;
    private static int y = 999;
    public static class OneImpl implements OneInterface{
        public void f(){
//            System.out.println("inner class" + x); 此处因为x不是static的，会提示编译错误。
            System.out.println("inner class " + y);
        }
    }

    public static void main(String[] args) {
        OneInterface one = new OneImpl();
        one.f();
    }
}

8.1.嵌套类的应用

由于接口中的属性和方法默认都是public static的，所以其中可以来嵌套一些需要子类实现都通用的方法。

public interface DemoInterface {
    void fun();
    class DemoImpl implements DemoInterface{
        public void fun(){
            System.out.println("可以实现我自己的外部接口");
        }
    }
}

public class DemoTest implements DemoInterface {
    @Override
    public void fun() {
        System.out.println("DemoTest");
    }

    public static void main(String[] args) {
        DemoInterface demo = new DemoTest();
        DemoInterface demo2 = new DemoImpl();
        demo.fun();
        demo2.fun();
    }
}

-----输出结果-----
DemoTest
可以实现我自己的外部接口

嵌套类不同于普通的内部类的另一点在于，编译生成的.class文件名称都是形如Outer$Inner.class这个格式。

而且嵌套类内部还能有嵌套类，以及static声明的属性及方法。

9.内部类无论内部有多少层，内一层的类都可以无条件的访问外部类

10.内部类存在的意义

内部类存在的主要目的是为了解决java没有多继承导致的一些麻烦

• java可以很好的解决多接口的实现问题，如下例子

public interface A {
}

public interface B {
}

public class X implements A,B {
}

public class Y implements A {
    B getB(){
        return new B() {};
    }
}

public class TestOne {
    public static void funA(A a) {

    }

    public static void funB(B b) {

    }

    public static void main(String[] args) {
        X x = new X();
        Y y = new Y();
        funA(x);
        funA(y);
        funB(x);
        funB(y.getB());
    }
}

• 但是对于要求子类同时实现抽象类和父类问题时，只有内部类可以派上用场

public class M {
}

public abstract class N {
}

public class Z extends M {
    N getN(){
        return new N() {};
    }
}

public class TestTwo {
    public static void funM(M m) {

    }
    public static void funN(N n) {

    }
    public static void main(String[] args) {
        Z z = new Z();
        funM(z);
        funN(z.getN());
    }
}

11.内部类的继承

内部类与外部类紧紧联系在一起，那么如果想要继承一个外部类的内部类，就需要使用到特殊的语法 OutClass.super();

public class DemoOuter {
    class Inner{}
}

public class ExtInner extends DemoOuter.Inner {
    public ExtInner(DemoOuter demoOuter){
        demoOuter.super(); //必须添加如此这般的构造器并显示指定父类对象引用
    }
}

12.内部类初始化顺序

内部类的构造器会先调用，然后才会调用外部类构造器。

内部类不存在覆盖问题,Egg中的Yolk和BigEgg中的Yolk完全是两个不同的类。

public class Egg {
    class Yolk{
        public Yolk(){
            System.out.println("Egg York"); // 1 3
        }
        public void f(){
            System.out.println("Egg f()");
        }
    }
    private Yolk york = new Yolk();
    public Egg(){
        System.out.println("Egg"); // 2
    }
    public void insert(Yolk y){
        this.york = y;
    }
    public void g(){
        york.f();
    }
}

public class BigEgg extends Egg {
    class Yolk extends Egg.Yolk{
        public Yolk(){
            System.out.println("BigEgg Yolk"); // 4
        }
        public void f(){
            System.out.println("BigEgg f()"); // 5
        }
    }

    public BigEgg(){
        insert(new Yolk());
    }

    public static void main(String[] args) {
        BigEgg egg = new BigEgg(); // 0
        egg.g();
    }
}

-----输出结果-----
Egg York
Egg
Egg York
BigEgg Yolk
BigEgg f()

13.局部内部类和匿名内部类的区别

前面讲过，将显示的类声明写出来，在返回一个对象的方式叫做局部内部类，但是如果直接new 接口并返回，那么他就是匿名内部类。

如果某个场景下，需要返回一个接口的多种不同实现，那么只有局部内部类做得到，匿名内部类是做不到的。

14.内部类标识符

匿名内部类 --> LocalInnerClass$1.class

局部内部类 --> LocalInnerClass$Inner.class