171120之内部类

什么是内部类？
内部类指的是在一个类的内部定义了其他类的情况，下面首先来看一下内部类的基本定义形式。

class Outer {       // 外部类         private String msg = "Hello World " ;      // 普通属性         class Inner {       // 内部类                   public void print() {                            System.out.println(msg) ;                   }         }         public void fun() {                   Inner in = new Inner() ;                   in.print() ;         }}public class TestDemo {         public static void main(String args[]) {                   Outer out = new Outer() ;                   out.fun() ;         }   注意匿名内部类和内部类的区别}

通过如上的代码相信首先最应该感受到的是：内部类属于在一个类内部定义的新的结构，不过按照类的基本组成来讲，一个类之中应该由属性和方法所组成，但是这个时候又多了一个类，这样的结构并不好，所以内部类本身最大的缺点破坏了程序的结构。

但是内部类本身也有自己的优点，而这个优点如果要想发现，最好的做法是将内部类拿到外面来，变为两个类。

class Outer {       // 外部类         private String msg = "Hello World " ;      // 普通属性         public void fun() {                   Inner in = new Inner(this) ;                   in.print() ;         }         public String getMsg() {                   return this.msg ;         }}class Inner {       // 内部类         private Outer out = null ;         public Inner(Outer out) {                   this.out = out ;         }         public void print() {                   System.out.println(this.out.getMsg()) ;         }}public class TestDemo {         public static void main(String args[]) {                   Outer out = new Outer() ;                   out.fun() ;         }}

这个时候感觉到代码所增加的复杂度是非常高的，那么很明显了，内部类的最大优点：可以方便的访问外部类的私有操作，或者是由外部类方便的访问内部类的私有操作。

class Outer {       // 外部类         private String msg = "Hello World " ;      // 普通属性         class Inner {        // 内部类                   private String info = "你好！" ;      // 内部类私有                   public void print() {                            System.out.println(msg) ;   // 内部类访问外部类                   }         }         public void fun() {                   Inner in = new Inner() ;                   in.print() ;                   System.out.println(in.info) ;        // 外部类直接调用         }}public class TestDemo {         public static void main(String args[]) {                   Outer out = new Outer() ;                   out.fun() ;         }}

但是这个时候一个严重的问题来了，在之前一直强调：只要是访问类中的属性前面都要有“this.”，即：以上的程序之中，内部类访问外部类私有属性的时候，应该是“this.msg”才对，但是在内部类使用this表示的只是内部类的当前对象，如果要想表示出外部类的当前对象，使用“外部类.this”来表示。

class Outer {       // 外部类         private String msg = "Hello World " ;      // 普通属性         class Inner {        // 内部类                   public void print() {                            System.out.println(Outer.this.msg) ;// 内部类访问外部类，Android开发之中，此代码常见                   }         }         public void fun() {                   Inner in = new Inner() ;                   in.print() ;         }}public class TestDemo {         public static void main(String args[]) {                   Outer out = new Outer() ;                   out.fun() ;         }}

以上的程序都是通过了外部类的方法操作了内部类，但是如何可以在不同的类操作内部类呢？

下面就可以给出在外部实例化内部类对象的操作格式：
外部类.内部类 内部类对象 = new 外部类().new 内部类() ;

之所以实例化外部类对象，主要是因为内部类需要访问外部类之中的普通属性，那么普通属性只有在对象实例化之后才会被实例化（可以使用）。

class Outer {       // 外部类         private String msg = "Hello World " ;      // 普通属性         class Inner {        // 内部类                   public void print() {                            System.out.println(Outer.this.msg) ;// 内部类访问外部类                   }         }}public class TestDemo {         public static void main(String args[]) {                   Outer.Inner in = new Outer().new Inner() ;  // 这种格式几乎不会出现                   in.print() ;         }}

但是，如果说现在内部类不希望被外面看见呢？那么可以继续进行封装操作。

class Outer {       // 外部类         private String msg = "Hello World " ;      // 普通属性         private class Inner {   // 内部类                   public void print() {                            System.out.println(Outer.this.msg) ;// 内部类访问外部类                   }         }}

使用static定义内部类
回顾：使用static定义的属性和方法，是独立于类之外的，可以在没有实例化对象的时候调用，而static也同样可以进行内部类的定义，而使用了static定义的内部类，则就表示为“外部类”，并且只能访问外部类之中static类型的操作。

class Outer {       // 外部类         private static String msg = "Hello World " ;       // 普通属性         static class Inner {        // 内部类 = ”外部类“                   public void print() {                            System.out.println(Outer.msg) ;// 内部类访问外部类                   }         }}public class TestDemo {         public static void main(String args[]) {                   Outer.Inner in = new Outer.Inner() ;                   in.print() ;         }}

在方法中定义内部类
内部类理论上可以在类的任意位置上进行定义，这就包括代码块之中，或者是普通方法之中，而在以后的开发过程之中，在普通方法里面定义内部类的情况是最多的。

class Outer {       // 外部类         private String msg = "Hello World " ;      // 普通属性         public void fun() {                   class Inner {        // 方法中定义的内部类                            public void print() {                                     System.out.println(Outer.this.msg) ;// 内部类访问外部类                            }                   }                   Inner in = new Inner() ;         // 产生内部类对象                   in.print() ;         }}public class TestDemo {         public static void main(String args[]) {                   new Outer().fun() ;         }}

但是一个内部类如果要定义在方法之中，并且要访问方法的参数或者是方法中定义变量的时候，这些参数或变量前一定要增加一个“final”关键字。

class Outer {       // 外部类         private String msg = "Hello World " ;      // 普通属性         public void fun(final int x) { // 参数                   final String info = "Hello MLDN" ;        // 变量                   class Inner {        // 方法中定义的内部类                            public void print() {                                     System.out.println(Outer.this.msg) ;                                     System.out.println(x) ;                                     System.out.println(info) ;                            }                   }                   Inner in = new Inner() ;         // 产生内部类对象                   in.print() ;         }}public class TestDemo {         public static void main(String args[]) {                   new Outer().fun(30) ;         }}