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