Java内部类学习笔记

20160923

• 定义：将一个类的定义放在另一个类的内部；
• 从外部类的非静态方法之外，创建某个内部类的对象：OutClassName.InnerClassName；
• 内部类拥有所有其外部类的成员的访问权；
• 成员内部类不能含有static修饰的变量和方法，因为成员内部类需要先创建了外部类，才能创建它自己的
• 内部类中生成外部类对象的引用，可以使用OutClassName.this；

 public class DoThis {
     void f(){System.out.println("DoThis.f()");}
     public class Inner{
         public DoThis getOuter(){
             return DoThis.this;
         }
     }
     public Inner getInner(){
         return new Inner();
     }
     public static void main(String[] args) {
         DoThis dThis = new DoThis();
         DoThis.Inner dThisInner = dThis.getInner();
         dThisInner.getOuter().f();
     }
 }

• 创建内部类的对象，必须使用外部类对象的引用；

 public class DoNew {
     public class Inner{};
     public static void main(String[] args) {
         DoNew doNew = new DoNew();
         DoNew.Inner dInner = doNew.new Inner();
     }
 }

• 创建嵌套类（静态内部类），不需要外部类对象的引用；
• private修饰的内部类，只能在其外部类内部访问；protected修饰的内部类，只有其外部类、其外部类的子类、其外部类同一个包中的其他类可以访问；

 class Parcel4{
     private class PContents implements Contents {
         private int i = 11;
         @Override
         public int value() { return i; }
     }
     protected class PDestination implements Destination {
         private String label;
         private PDestination(String whereTo) { label = whereTo; }
         @Override
         public String readLabel() { return label; }
     }
     public Destination destination(String s){ return new PDestination(s); }
     public Contents contents(){ return new PContents(); }
     Parcel4.PContents t;//PContents是private，只能在Parcel4内部访问
 }
 public class TestParcel {
     public static void main(String[] args) {
         Parcel4 p = new Parcel4();
         Contents contents = p.contents();
         Destination destination = p.destination("Tasmania");
         //Parcel4.PContents pc = p.new PContents();//PContents是private，只能在Parcel4内部访问，此处报错
     }
 }

• 复杂的内部类：在方法或作用域内定义内部类，理由如下：

1. 实现了某个类型的接口，可以创建并返回对接口的引用
2. 需解决复杂的问题，想创建一个类辅助实现解决方案，但不希望这个类被公用

• 举例

　　　　1、一个定义在方法中的类

 public class Parcel5 {
     public Destination destination(String s){
         class PDestination implements Destination{
             private String label;
             private PDestination(String whereTo){
                 label = whereTo;
             }
             @Override
             public String readLabel() { return label; }
         }
         return new PDestination(s);
     }
     public static void main(String[] args) {
         Parcel5 p = new Parcel5();
         Destination destination = p.destination("Tasmania");
     }
 }

　　　　2、一个定义在作用域中的类，作用域在方法的内部

 public class Parcel6 {
     private void internalTracking(boolean b) {
         if (b){
             class TrackingSlip {
                 private String id;
                 public TrackingSlip(String s) {
                     id = s;
                 }
                 String getSlip(){ return id;}
             }
             TrackingSlip ts = new TrackingSlip("slip");
             String s = ts.getSlip();
         }
         //Can't use it here!Out of scope:
         //TrackingSlip ts = new TrackingSlip("x");
     }
     public void track(){internalTracking(true);}
     public static void main(String[] args) {
         Parcel6 p = new Parcel6();
         p.track();
     }
 }

　　　　3、一个实现了接口的匿名类

　　　　4、一个匿名类，扩展了有非默认构造器的类

　　　　5、一个匿名类，执行字段初始化

　　　　6、一个匿名类，通过实例初始化实现构造（匿名类没有构造器）

• 传递给匿名内部类的参数，并且在匿名内部类中使用，该参数须定义为final；
• 匿名内部类可扩展类，也可以实现接口，但不能同时；如果实现接口，只能实现一个接口；
• 《Java编程思想》199页，10.6.1再访工厂方法，使用匿名内部类的例子，非常好；
• 嵌套类：static修饰的内部类，无法访问非静态的外部类对象
• 嵌套类可以作为接口的一部分，甚至实现外部接口

•  public interface ClassInInterface {
       void howdy();
       class Test implements ClassInInterface{
           @Override
           public void howdy() { System.out.println("Howdy"); }
           public static void main(String[] args){
               new Test().howdy();
           }
       }
   }

• 内部类能够多层嵌套，并且能够透明的访问所有它嵌入的外部类的成员

•  class A{
       private void f(){}
       class B {
           private void g(){}
           public class C {
               void h() {
                   g();
                   f();
               }
           }
       }
   }
   public class MultiNestingAccess {
       public static void main(String[] args) {
           A a = new A();
           A.B ab = a.new B();
           A.B.C abc =ab.new C();
           abc.h();
       }
   }

• 为什么需要内部类？
• 《Java编程思想》204页解释为：每个内部类都能独立的继承自一个（接口的）实现，所以无论外围类是否已经继承了某个（接口的）实现，对于内部类都没有影响；
• 简单讲就是，内部类实现接口、继承某个类，比外部类实现接口少了许多顾虑，外部类实现接口需要考虑全面，在其他地方是否有影响；
• 内部类可以继承多个具体类或抽象类，与接口配合，使“多重继承”的解决方案变得完美；
• 内部类可以有多个实例，每个实例都有自己的状态信息，并且与外部类对象相互独立；
• 在单个外部类中，可以使多个内部类以不同的方式实现同一个接口，或继承同一个类；
• 内部类对象的创建，并不依赖于外部类对象的创建
• 内部类没有“is-a”关系，内部类是独立的实体
• 闭包，记录了创建闭包的作用域的一些信息，使得闭包可调用其外部作用域数据；内部类就是面向对象的闭包；
• 回调，
• 通过内部类提供闭包功能举例：

•  package com.helei.innerclasses;
   interface Incrementable {
       void increment();
   }
   class Callee1 implements Incrementable {
       private int i = 0;
       @Override
       public void increment() {
           i++;
           System.out.println(i);;
       }
   }
   class MyIncrement {
       public void increment() { System.out.println("Other operation");}
       static void f(MyIncrement mi) {mi.increment();}
   }
   class Callee2 extends MyIncrement {
       private int i = 0;
       public void increment() {
           super.increment();
           i++;
           System.out.println(i);
       }
       private class Closure implements Incrementable {
           public void increment() {
               Callee2.this.increment();
           }
       }
       Incrementable getCallbackReference() {
           return new Closure();
       }
   }
   class Caller {
       private Incrementable callbackReference;
       Caller(Incrementable cbh){callbackReference = cbh;}
       void go() {callbackReference.increment();}
   }
   public class Callbacks {
       public static void main(String[] args) {
           Callee1 c1 = new Callee1();
           Callee2 c2 = new Callee2();
           MyIncrement.f(c2);
           Caller caller1 = new Caller(c1);
           Caller caller2 = new Caller(c2.getCallbackReference());
           caller1.go();
           caller1.go();
           caller2.go();
           caller2.go();
       }
   }

• 看了好几遍才梳通了以上流程，最好能够敲一遍，通过debug调试过一遍
• 内部类与控制框架
• 内部类的继承
• 内部类覆盖，无效；可以显式继承某内部类；
• 局部内部类，与匿名内部类的区别