java中的内部类

主要问题：内部类何时被初始化，怎样调用内部类。

---

内部类是指在一个外部类的内部再定义一个类。类名不需要和文件夹相同。
*内部类可以是静态static的，也可用public，default，protected和private修饰。（而外部顶级类即类名和文件名相同的只能使用public和default）。

内部类分为成员内部类、静态嵌套类、方法内部类、匿名内部类。

几种内部类的共性：
A、内部类仍然是一个独立的类，在编译之后会内部类会被编译成独立的.class文件，但是前面冠以外部类的类名和$符号。
所以内部类的成员变量/方法名可以和外部类的相同。
B、内部类不能用普通的方式访问。内部类是外部类的一个成员，因此内部类可以自由地访问外部类的成员变量，无论是否是private的。

1 . 成员内部类
成员内部类不能含有static的变量和方法。因为成员内部类需要先创建了外部类，才有可能创建它自己的。

A、从外部类的非静态方法中实例化内部类对象。

public class Outer {    public static void main(String[] args) {        int a = 4;    }    public void makeInner(){        inner1 in = new inner1();        in.out();    }    class inner1{        public void out(){        }    }}

表面上，我们并没有创建外部类的对象就实例化了内部类对象，和上面的话矛盾。事实上，如果不创建外部类对象也就不可能调用makeInner()方法，所以到头来还是要创建外部类对象的。

B、从外部类的静态方法中实例化内部类对象。

public static void main(String[] args) {        int a = 4;        Outer out = new Outer();        Outer.inner1 in = out.new inner1();        //Outer.Inner in = new Outer().new Inner();    }

C、内部类的this引用。
普通的类可以用this引用当前的对象，内部类也是如此。但是假若内部类想引用外部类当前的对象呢？用“外部类名”.this；的形式,如下例的Outer.this。

class inner1{        public void out(){            System.out.println(Outer.this.b); // b是Outer的成员变量        }    }

D、成员内部类的修饰符。
对于普通的类，可用的修饰符有final、abstract、strictfp、public和默认的包访问。
但是成员内部类更像一个成员变量和方法。
可用的修饰符有：final、abstract、public、private、protected、strictfp和static。
一旦用static修饰内部类，它就变成静态内部类了。

---

2.局部内部类
局部内部类，是指内部类定义在方法和作用域内。Thinking in Java给了这么两个例子：
定义在方法内：

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

定义在方法中的又称为方法内部类。
A、方法内部类只能在定义该内部类的方法内实例化，不可以在此方法外对其实例化。

B、方法内部类的修饰符。
与成员内部类不同，方法内部类更像一个局部变量。（ 局部变量本身就是一个访问权限 的设定，前面不能再加访问修饰符）
可以用于修饰方法内部类的只有final和abstract。

C、静态方法内的方法内部类。
静态方法是没有this引用的，因此在静态方法内的内部类遭受同样的待遇，即：只能访问外部类的静态成员。

定义在作用域里：

public class Parcel5 {     private void internalTracking(boolean b) {         if (b) {             class TrackingSlip {                 private String id;                 TrackingSlip(String s) {                     id = s;                 }                 String getSlip() {                     return id;                 }             }             TrackingSlip ts = new TrackingSlip("slip");             String s = ts.getSlip();         }     }     public void track() {         internalTracking(true);     }     public static void main(String[] args) {         Parcel5 p = new Parcel5();         p.track();     } } 

局部内部类也像别的类一样进行编译，但只是作用域不同而已，只在该方法或条件的作用域内才能使用，退出这些作用域后无法引用的。

---

3.嵌套内部类
嵌套内部类，就是修饰为static的内部类。声明为static的内部类，不需要内部类对象和外部类对象之间的联系，就是说我们可以直接引用outer.inner，即不需要创建外部类，也不需要创建内部类。
嵌套类和普通的内部类还有一个区别：普通内部类不能有static数据和static属性，也不能包含嵌套类，但嵌套类可以（可以理解成嵌套类就是一个独立的类）。而嵌套类不能声明为private，一般声明为public，方便调用。

---

4.匿名内部类
有时候我为了免去给内部类命名，便倾向于使用匿名内部类，因为它没有名字。例如：

((Button) findViewById(R.id.start)).setOnClickListener(new Button.OnClickListener() {     @Override     public void onClick(View v) {         new Thread() {             @Override             public void run() {                 // TODO Auto-generated method stub             }         }.start();     } }); 

匿名内部类是不能加访问修饰符的。要注意的是，new 匿名类，这个类是要先定义的，看下面例子：

public class Outer {     public static void main(String[] args) {         Outer outer = new Outer();         Inner inner = outer.getInner("Inner", "gz");         System.out.println(inner.getName());     }     public Inner getInner(final String name, String city) {         return new Inner() {             private String nameStr = name;             public String getName() {                 return nameStr;             }         };     } } //注释后，编译时提示类Inner找不到 /* interface Inner {     String getName(); } */ 

同时在这个例子，留意外部类的方法的形参，当所在的方法的形参需要被内部类里面使用时，该形参必须为final。这里可以看到形参name已经定义为final了，而形参city 没有被使用则不用定义为final。为什么要定义为final呢？在网上找到本人比较如同的解释：
“这是一个编译器设计的问题，如果你了解java的编译原理的话很容易理解。
首先，内部类被编译的时候会生成一个单独的内部类的.class文件，这个文件并不与外部类在同一class文件中。
当外部类传的参数被内部类调用时，从java程序的角度来看是直接的调用例如

public void dosome(final String a,final int b){    class Dosome{public void dosome(){System.out.println(a+b)}};    Dosome some=new Dosome();    some.dosome();  }  

来看好像是那个内部类直接调用的a参数和b参数，但是实际上不是，在java编译器编译以后实际的操作代码是

class Outer$Dosome{    public Dosome(final String a,final int b){    this.Dosome$a=a;    this.Dosome$b=b;  }    public void dosome(){    System.out.println(this.Dosome$a+this.Dosome$b);  }  }}  

从以上代码看来，内部类并不是直接调用方法传进来的参数，而是内部类将传进来的参数通过自己的构造器备份到了自己的内部，自己内部的方法调用的实际是自己的属性而不是外部类方法的参数。
这样理解就很容易得出为什么要用final了，因为两者从外表看起来是同一个东西，实际上却不是这样，如果内部类改掉了这些参数的值也不可能影响到原参数，然而这样却失去了参数的一致性，因为从编程人员的角度来看他们是同一个东西，如果编程人员在程序设计的时候在内部类中改掉参数的值，但是外部调用的时候又发现值其实没有被改掉，这就让人非常的难以理解和接受，为了避免这种尴尬的问题存在，所以编译器设计人员把内部类能够使用的参数设定为必须是final来规避这种莫名其妙错误的存在。”
(简单理解就是，拷贝引用，为了避免引用值发生改变，例如被外部类的方法修改等，而导致内部类得到的值不一致，于是用final来让该引用不可改变)

匿名内部类通过实例初始化，可以达到类似构造器的效果：

public class Outer {     public static void main(String[] args) {         Outer outer = new Outer();         Inner inner = outer.getInner("Inner", "gz");         System.out.println(inner.getName());         System.out.println(inner.getProvince());     }     public Inner getInner(final String name, final String city) {         return new Inner() {             private String nameStr = name;             private String province;             // 实例初始化             {                 if (city.equals("gz")) {                     province = "gd";                 }else {                     province = "";                 }             }             public String getName() {                 return nameStr;             }             public String getProvince() {                 return province;             }         };     } } interface Inner {     String getName();     String getProvince(); }