thinking in java笔记 10 内部类

***访问

    1.从外部类的（非静态方法）之外的地方创建内部类对象时，需要使用Outerclass.innerclass来指明类型

    2.内部类拥有对外部类所有元素的访问权，内部类隐式地保存了一个指向外部类对象的引用。

    3..this .new

      在内部类中，可以使用OuterClass.this获取对外部类对象的引用。

      不能直接生产内部类对象，而是通过外部类对象来创建，如

      OutClass outer= new OutClass();
      OuterClass .InnerClass inner=outer. new InnerClass();

   4.外部类可以访问内部类的private元素。

***private内部类

    可以完全阻止任何依赖于类型的编码，并且完全隐藏了实现的细节。除了OuterClass,都无法访问到它。

***内部类使用范围

    内部类可在任意地方使用，同变量一样，有其作用区域，在区域外无效。

***匿名内部类

    在匿名内部类中使用外部定义的对象时，参数引用必须是final类型的。

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

    匿名类内部没有命名构造器，但通过实例初始化，可以模拟构造器的效果：

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

***嵌套类

    内部类为static

    1.要创建嵌套类的对象，不需要其外围类的对象

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

    3.普通的内部类不能包含static数据和字段，也不能包含嵌套类。嵌套类可以包含。

***为什么使用内部类

    内部类继承自某个类或实现某个接口，内部类的代码操作创建它的外围类的对象，所以可以认为内部类提供了某种进入其外部类的窗口。

    当要对类实现多重继承时，需使用内部类来解决，如下：

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

    内部类的特性：

    1 内部类可以有多个实例，每个实例有自己的状态信息，并且与其外围类对象的信息相互独立。

    2 在单个外围类中，可以让多个内部类以不同的方式实现同一个接口，或继承同一个类。

    3 创建内部类对象时并不依赖于外部类对象的创建

    4 内部类没有令人迷惑的is-a关系，它是一个独立的实体。

    回调可通过内部类实现，在内部类中实现接口，以提供一个hook供外界调用。回调的价值在于其灵活性，可以在运行时动态地决定需要调用什么方法。

***内部类的继承

    因为内部类的构造器必须连接到指向其外部类对象的引用，所以继承内部类时需按如下方法：

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

***局部内部类

    可以在代码块中创建内部类，称为局部内部类。其不能有访问说明符，不是外围类的一部分，能访问外围类的所有成员和当前方法内的变量，只在方法范围内有效。

    用它而不是匿名内部类的情况：

      1 需要一个已命名的构造器，或者需要重载构造器，而匿名内部类只能用于实例初始化。

      2 需要不止一个该内部类的对象。