#Thinking in Java阅读笔记# 第十章 内部类

创建内部类

内部类的创建：把内部类的定义放置在外部类的定义之中，在非静态方法中创建内部类时，内部类的使用就和组合类一样。但是在非静态方法之外的部分创建内部类，必须要对内部类的对象变量声明为:OuterClassName.InnerClassName

public class TestJava {    class inner{        public void print() {            System.out.println("inner");        };    }    public inner test() {        return new inner();//返回内部类的引用    }    public static void main(String[] args) {        TestJava t = new TestJava();        TestJava.inner i = t.test();//OuterClassName.InnerClassName        i.print();    }}

链接到外部类

在外部类对象创建一个内部类对象时，内部类对象会捕捉到外部类对象的引用，从而使得内部类能通过这个引用来使用外部类中的任意成员（域和方法），从而使得内部类与创造它的外部类之间有一种联系（1.内部类对象有外部类对象的引用 2.内部类的创建依赖于外部类（比如外部类中有方法返回内部类，如上述））。内部类只有在与其外部类对象相关联的情况下才能被创建（即内部类不为static）。

内部类对象为何能直接访问外部类成员？
1 编译器自动为内部类添加一个成员变量， 这个成员变量的类型和外部类的类型相同， 这个成员变量就是指向外部类对象的引用；
2 编译器自动为内部类的构造方法添加一个参数， 参数的类型是外部类的类型， 在构造方法内部使用这个参数为1中添加的成员变量赋值；
3 在调用内部类的构造函数初始化内部类对象时， 会默认传入外部类的引用。

使用.this/.new

1.如果要生成外部类的引用，可以使用OuterClassName.this

public class TestJava {    class inner{        public TestJava r() {            return TestJava.this;//返回外部类的引用        }    }    public void print() {        System.out.println("OuterClass");    }    public inner test() {        return new inner();//返回内部类的引用    }    public static void main(String[] args) {        TestJava t = new TestJava();        TestJava.inner i = t.test();//OuterClassName.InnerClassName        i.r().print();//return TestJava的引用，再调用外部类的print()方法    }}

2.如果想直接创建内部类的对象（而不是通过调用外部类的函数），则需要使用外部类的对象来创建内部类的对象，用外部类对象的引用调用.new语法，内部类对象的创建一定要基于外部类之上

public class TestJava {    class inner{        public inner() {            System.out.println("Inner");        }    }    public static void main(String[] args) {        TestJava t = new TestJava();        TestJava.inner i = t.new inner();//告知外部类对象创建内部类对象，则需要提供外部类的引用来调用.new    }}

内部类可以直接访问外部类的成员：

public class TestJava {    private String s;    class inner{        public void str() {            s = "123";//外部类的成员可以直接访问，甚至是Private            print();            System.out.println(s);        }    }    private void print() {        System.out.println("outer");    }    public static void main(String[] args) {        TestJava t = new TestJava();        t.new inner().str();    }}

而外部类需要建立内部类的实例后才能访问内部类的成员：

public class TestJava {    class inner{        private String s;        private void print() {            this.s = "Hello"+s;            System.out.println(s);        }    }    public void outer() {        inner i = new inner();        i.s = " World!";//需要构建内部类实例        i.print();    }    public static void main(String[] args) {        TestJava t = new TestJava();        t.outer();    }}

内部类与向上转型

用内部类实现了某接口，可以方便的向上转型，从而很好的隐藏实现细节。

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

局部内部类：在一个方法中插入内部类

interface itf{    void print();    void out();}public class Test{    public itf inner(){        class in implements itf{            public void print(){                System.out.print("Inner");            }            public void out(){                System.out.print("out");            }        }    return new in();    }    public static void main(String[] args){        Test t = new Test;        t.inner().print();      }这个内部类的作用域就是在此方法内，外部无法看见。这种方式可以方便的实现itf接口，从而让Test类通过只调用函数自身的函数来得到不同实现的接口。

匿名内部类

匿名内部类，没有名字，所以它没有构造器（因为构造器要求和类同名），可以实现一个接口或者扩展于一个类：
1.实现于接口时，一定不能传递参数给它，因为接口没有构造器。
格式：

new InterfaceType(){    methods and data;}public class TestJava {    ActionListener listener = new ActionListener() {        public void actionPerform() {            System.out.println("1");        }    };}

2.扩展于某类时，如果其基类的构造函数需要传递参数，则需要将参数加入new Class(…)中，如果此参数只用于基类的构造器，则不用设定为final，如果内部类中需要使用此参数，则需要设定为final

new SuperType(constructor parameters){    methods and data;}class Sup{    private int i;    public Sup(int x) {this.i = x;}    public int value() {return i;}}public class TestJava {    public Sup test(int x) {        return new Sup(x) {//自动调用基类的构造器            public int value() {                return super.value() * 47;            }        };    }    public static void main(String[] args) {        TestJava t = new TestJava();        System.out.println(t.test(5).value());    }}