Think In Java 10 内部类

名词解释

• 内部类: 一个类的定义再另外一个类的内部
• 外围类: 包含内部类的那个类
• 外部类: 指那些类相对于包含内部类的那个类

10.1 内部类的创建

把类的定义置于外部类的里面

使用方法:

1. 在外围类的内部，与使用普通类没有什么区别
2. 典型情况， 在外围类的内部有一个方法，该方法返回一个指向内部类的引用。
3. 想从外部类的非静态方法之外的任意位置创将某个内部类的对象，必须具体地指明这个对象的类型: OutClassName.InnerClassName.

10.2 链接到外部类

当生成一个内部类对象的时候，此对象与制造他的外围类 对象之间就有一种特殊联系：它能访问外围类的所有成员和外围类所有元素的访问权。

Sample 1:内部类实现迭代器设计模式

class SeQueue{
    private int size;
    private String [] arr;
    public SeQueue(int size){
        this.size = size;
        arr = new String [size];
        initArr();
    }

    private void initArr(){
        for (int i = 0 ; i < size ;i++){
            arr[i] = ""+i;
        }
    }

    public Iterator getIter(){
        return new Iterator();
    }

    class Iterator{
        public Iterator(){

        }

        int temp = 0;
        public String next(){
            int ret;
            if (temp < size) {
                ret = temp;
                temp++;
                return arr[ret];
            }else {
                temp = 0;
                return "over";
            }
        }
    }

    public static void main(String[] args){
        SeQueue se = new SeQueue(10);

        Iterator iter = se.getIter();

        for (int i = 0 ; i< 12 ;i++ ) {
            System.out.println(iter.next());
        }
    }   
}

10.3 使用.this 与 .new

• .this生成对外围类对象的引用
• .new告知其他类创建某个内部类对象

Sample 2:.this 和 .new 的Demo

public class OutClass{
    public class InnerClass{
        public OutClass getOut(){
            // .this 生成对外部类对象的引用
            return OutClass.this;
        }
    }
    public static void main(String[] args){
        //.new 告知其他类创建某个内部类对象
            OutClass out = new OutClass();
            InnerClass inner = out.new InnerClass();
    }
}

Important: 在拥有外部类对象之前是不可能创建内部类对象。这是因为内部类对象回悄悄链接到一个外部类对象。。但是，如果你创建的是一个嵌套类(静态内部类)，那么他就不需要对外部类对象的引用

10.4 内部类与想向上转型

实现隐藏细节的一个方法
总结: 当内部类的访问修饰词不同时，当内部类向上转型为基类或转型为一个接口的的引用，外围类对内部类是完全不可见的。

Sample 3:接口内部类向上转型Demo

class Pricel4{
    private class PContents implements Contents{
        private int i = 11;
        public int value(){
            return i;
        }
    }

    private class PDestination implements Destination{
        private String label;
        private PDestination(String name){
            label = name;
        }
        public String readLine(){
            return label;
        }
    }

    public PDestination destination(String s){
        return new PDestination(s);
    }

    public PContents pContents(){
        return new PContents();
    }

    public static void main(String[] args){ 
        Pricel4 p = new Pricel4();
        Contents c = p.pContents();
        Destination d = p.destination("test");
        System.out.println(d.readLine() + c.value());

        //Illegal
        /*Pricel4.PContents pc = p.new PContents();*/

    }

}

interface Destination{
    String readLine();
}

interface Contents{
    int value();
}

10.5在方法和作用域内部的内部类

主要作用:1.实现某类型的接口，于是可以创建和返回对其的引用
创建一个非公共的辅助类来辅助复杂问题的解决方案

内部类的实现
1. 一个定义再方法中的类
2. 一个定义再作用域中的类，此作用域再方法的内部
3. 一个实现了接口的匿名类
4. 一个匿名类，它扩展来有非默认构造函数的类
5. 一个匿名类，它执行字段初始化
6. 一个匿名类，他通过实例初始化实现构造（匿名类不可能有构造器）

10.6 匿名内部类

匿名类： 没有名字的类既可以是类的扩展，也可以实现接口，但是不能两者兼备。而且实现接口，也只能实现一个接口。

可以使用 匿名内部类 + 构造者模式 来实现工厂方法。

10.8 为什么需要内部类

内部类最吸引人的: 每个内部类都能独立地继承自一个(接口的)实现，所以无论外围类是否已经继承了某个(接口的)实现，对于内部类都没有影响。