《Java编程思想》笔记 第十章 内部类

1.创建内部类对象

1. 创建内部类对象（相当于new内部类对象） 外围类对象.new 内部类( )。
2. 创建内部类对象一种方法是 外围类有一个方法返回内部类对象。
3. 没有外围类对象就不能创建内部类对象，因为内部类对象会暗暗连接到外围类对象上。
4. 如果是嵌套类（静态内部类）无需外围类对象引用就可创建。Outer.Inner in  = Outer.Inner();

2.创建内部类引用 in

• Outer.Inner in ，无论在什么其他类内还是在所在的外围类内。
• 内部类内创建外围类对象引用out : Outer.this out

3. 匿名内部类

• 只知其超类不知其自身叫什么类。

public Test f(){

        return new Test(){         // 从方法返回值可以看出要返回一个Test对象，new Test(){}; 就是一个Test的匿名内部类对象，
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　
            //类数据成员                  //  Test是匿名内部类的基类
            //类方法　　　　　　　　　　　　　// 在匿名内部类内可以定义额外的方法，成员，也可以覆写Test的方法。
        };

    }

结果：  调用一次f()就创建了一个继承自Test的匿名对象，并自动向上转型为Test引用，并返回这个引用。

1. 匿名内部类如果需要一个外围类定义的对象那么这个对象的参数一定是final

   public Test f( final String a1){
   
       return new Test() {   
   
           String s = a1;
   
       };
   
   }

2. 匿名内部类没有名字也就谈不上有构造器（构造器必须类名相同），若想在创建匿名对象时执行初始化行为就像构造器那样，通过实例初始化，就可以做到构造器行为。
3. 要扩展一个类可以继承或者实现接口，而且能实现多个接口，而使用匿名内部类来扩展类，那么一个匿名内部类要么继承，要么实现接口，实现接口也只能实现一个。

   class A extends B implements C,D{    //要扩展A 可以同时继承B,实现C,D多个接口
   
       Animal f = new Animal() {    //使用匿名内部类，一个匿名内部类只能实现一个接口，而且不能再继承，
                                   // 当然可以使用多个匿名内部类分别实现继承，或者其他接口
   
           @Override
           public void fly() {
               // A 中的匿名内部类 实现了接口
   
           }
       };
   }

4. 线程常用的一个匿名内部类的例子

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        new Thread().start();  //启动一个线程

        new Thread(new Runnable() {   // 使用Thread类的public Thread(Runnable target)构造器，
                                     //向里传入一个实现Runnable接口的匿名内部类，并启动。

            @Override
            public void run() {
                // TODO Auto-generated method stub

            }
        } ).start();

        new Thread(){public void run() {};}.start(); // 创建一个Thread类的匿名内部类，覆写run方法，并启动。

    }

4.嵌套类

• static 内部类 ，内外部类对象间无联系。 static类就是一个单独的存在，只是把它放在了一个类中。

1. 嵌套类因为是静态的所以不能访问外围类的非静态成员对象
2. 普通内部类不能有 static 字段和static数据成员，也不能再嵌套一个内部类，但嵌套类这些都可以有。

5.接口的内部类

• 因为接口中任何类自动都是public和static，故无需写static也是嵌套

6.为什么需要内部类

• 内部类可以解决部分多重继承问题
• 内部类可以独立继承实现接口，与外围类是否继承了该接口无关。
• 内部类操作外围类的对象，提供进入外围类的窗口

7.闭包

• 闭包是对象，记录了一些来自于创建它的作用域的对象。

8.什么是回调。

• A给B发消息，B处理完后调用A的方法执行处理结果。
• 回调的灵活性： 在运行时动态的决定调用什么方法。

9.继承内部类

class B {
    class A {
    }
}

class C extends B.A {        //C只继承内部类
    C(B b) {                //创建C对象需要调用A的构造器，但调用A的构造器必须有B的引用
        b.super();            //给C的构造器传入一个B的引用，然后调用基类A的构造器
    }
}

注意： b.super()代表用B引用调用C类的基类构造器，而不是调用B基类的构造器

1. 子类覆写基类的内部类后，这两个内部类就是两个独立的内部类，因为所在命名空间不同，与方法覆写不同。
2. 内部类可以继承内部类，作为基类的内部类一定是Outer.Inner

10. 局部内部类

-------以后补充

知识点

1. 多层嵌套中，不管嵌套了多少层它们总归在一个类中，同一个类内成员间可以相互访问（但要注意是不是static），哪怕是private
2. 应用程序框架：是被用来以解决某些特定问题的一个类或者一组类。
3. 控制框架是特殊的应用框架。