9）Java内部类（Inner Class）

 
内部类：不可以有静态数据，静态方法或者又一个静态内部类
     内部类的优点：隐藏类的细节，内部类可以声明为私有。内部类可以访问外部类的对象（包括private）
静态内部类：可以有静态数据，静态方法或者又一个静态内部类
局部内部类：定义在一个方法或者一个代码块中的类，作用域为相应代码块
匿名内部类：该类没有名字，一般直接写为（new 接口（..））并返回一个实现了某接口的对象。
 
为什么需要内部类？
     典型的情况是，内部类继承自某个类或实现某个接口，内部类的代码操作创建其的外围类的对象。所以你可以认为内部类提供了某种进入其外围类的窗口。
 
使用内部类最吸引人的原因是：
     每个内部类都能独立地继承自一个（接口的）实现，所以无论外围类是否已经继承了某个（接口的）实现，对于内部类都没有影响。如果没有内部类提供的可以继承多个具体的或抽象的类的能力，一些设计与编程问题就很难解决。从这个角度看，内部类使得多重继承的解决方案变得完整。接口解决了部分问题，而内部类有效地实现了“多重继承”。
 
  1. public interface Contents {  
  2.     int value();  
  3. }  
  4. public interface Destination {  
  5.     String readLabel();  
  6. }  
  7. public class Goods {  
  8.     private class Content implements Contents {  
  9.         private int i = 11;  
  10.         public int value() {  
  11.             return i;  
  12.         }  
  13.     }  
  14.     protected class GDestination implements Destination {  
  15.         private String label;  
  16.         private GDestination(String whereTo) {  
  17.             label = whereTo;  
  18.         }  
  19.         public String readLabel() {  
  20.             return label;  
  21.         }  
  22.     }  
  23.     public Destination dest(String s) {  
  24.         return new GDestination(s);  
  25.     }  
  26.     public Contents cont() {  
  27.         return new Content();  
  28.     }  
  29. }  
  30. class TestGoods {  
  31.     public static void main(String[] args) {  
  32.         Goods p = new Goods();  
  33.         Contents c = p.cont();  
  34.         Destination d = p.dest("Beijing");  
  35.     }  
  36. }  
     在这个例子里类Content和GDestination被定义在了类Goods内部，并且分别有着protected和private修饰符来控制访问级别。Content代表着Goods的内容，而GDestination代表着Goods的目的地。它们分别实现了两个接口Content和Destination。在后面的main方法里，直接用 Contents c和Destination d进行操作，你甚至连这两个内部类的名字都没有看见！这样，内部类的第一个好处就体现出来了 隐藏你不想让别人知道的操作，也即封装性。
同时，我们也发现了在外部类作用范围之外得到内部类对象的第一个方法，那就是利用其外部类的方法创建并返回。上例中的cont()和dest()方法就是这么做的。那么还有没有别的方法呢？当然有，其语法格式如下：
outerObject=new outerClass(Constructor Parameters);
outerClass.innerClass innerObject=outerObject.new InnerClass(Constructor Parameters);
注意在创建非静态内部类对象时，一定要先创建起相应的外部类对象。至于原因，也就引出了我们下一个话题 非静态内部类对象有着指向其外部类对象的引用，对刚才的例子稍作修改：
  1. public class Goods {  
  2.     private int valueRate = 2;  
  3.     private class Content implements Contents {  
  4.         private int i = 11 * valueRate;  
  5.         public int value() {  
  6.             return i;  
  7.         }  
  8.     }  
  9.     protected class GDestination implements Destination {  
  10.         private String label;  
  11.         private GDestination(String whereTo) {  
  12.             label = whereTo;  
  13.         }  
  14.         public String readLabel() {  
  15.             return label;  
  16.         }  
  17.     }  
  18.     public Destination dest(String s) {  
  19.         return new GDestination(s);  
  20.     }  
  21.     public Contents cont() {  
  22.         return new Content();  
  23.     }  
  24. }  
     在这里我们给Goods类增加了一个private成员变量valueRate，意义是货物的价值系数，在内部类Content的方法value()计算价值时把它乘上。我们发现，value()可以访问valueRate，这也是内部类的第二个好处 一个内部类对象可以访问创建它的外部类对象的内容，甚至包括私有变量！这是一个非常有用的特性，为我们在设计时提供了更多的思路和捷径。要想实现这个功能，内部类对象就必须有指向外部类对象的引用。Java编译器在创建内部类对象时，隐式的把其外部类对象的引用也传了进去并一直保存着。这样就使得内部类对象始终可以访问其外部类对象，同时这也是为什么在外部类作用范围之外向要创建内部类对象必须先创建其外部类对象的原因。
     有人会问，如果内部类里的一个成员变量与外部类的一个成员变量同名，也即外部类的同名成员变量被屏蔽了，怎么办？没事，Java里用如下格式表达外部类的引用：
outerClass.this
     有了它，我们就不怕这种屏蔽的情况了。
静态内部类
     和普通的类一样，内部类也可以有静态的。不过和非静态内部类相比，区别就在于静态内部类没有了指向外部的引用。这实际上和C++中的嵌套类很相像了，Java内部类与C++嵌套类最大的不同就在于是否有指向外部的引用这一点上，当然从设计的角度以及以它一些细节来讲还有区别。
除此之外，在任何非静态内部类中，都不能有静态数据，静态方法或者又一个静态内部类（内部类的嵌套可以不止一层）。不过静态内部类中却可以拥有这一切。这也算是两者的第二个区别吧。
局部内部类
     是的，Java内部类也可以是局部的，它可以定义在一个方法甚至一个代码块之内。
  1. public class Goods1 {  
  2.     public Destination dest(String s) {  
  3.         class GDestination implements Destination {  
  4.             private String label;  
  5.             private GDestination(String whereTo) {  
  6.                 label = whereTo;  
  7.             }  
  8.             public String readLabel() {  
  9.                 return label;  
  10.             }  
  11.         }  
  12.         return new GDestination(s);  
  13.     }  
  14.     public static void main(String[] args) {  
  15.         Goods1 g = new Goods1();  
  16.         Destination d = g.dest("Beijing");  
  17.     }  
  18. }  
     上面就是这样一个例子。在方法dest中我们定义了一个内部类，最后由这个方法返回这个内部类的对象。如果我们在用一个内部类的时候仅需要创建它的一个对象并创给外部，就可以这样做。当然，定义在方法中的内部类可以使设计多样化，用途绝不仅仅在这一点。
     下面有一个更怪的例子：
  1. public class Goods2 {  
  2.     private void internalTracking(boolean b) {  
  3.         if (b) {  
  4.             class TrackingSlip {  
  5.                 private String id;  
  6.                 TrackingSlip(String s) {  
  7.                     id = s;  
  8.                 }  
  9.                 String getSlip() {  
  10.                     return id;  
  11.                 }  
  12.             }  
  13.             TrackingSlip ts = new TrackingSlip("slip");  
  14.             String s = ts.getSlip();  
  15.         }  
  16.     }  
  17.     public void track() {  
  18.         internalTracking(true);  
  19.     }  
  20.     public static void main(String[] args) {  
  21.         Goods2 g = new Goods2();  
  22.         g.track();  
  23.     }  
  24. }  
     你不能在if之外创建这个内部类的对象，因为这已经超出了它的作用域。不过在编译的时候，内部类TrackingSlip和其他类一样同时被编译，只不过它由它自己的作用域，超出了这个范围就无效，除此之外它和其他内部类并没有区别。
匿名内部类
     匿名类是不能有名称的类，所以没办法引用它们。必须在创建时，作为new语句的一部分来声明它们。这就要采用另一种形式的new语句，如下所示： new <类或接口> <类的主体> 这种形式的new语句声明一个新的匿名类，它对一个给定的类进行扩展，或者实现一个给定的接口。它还创建那个类的一个新实例，并把它作为语句的结果而返回。
     java的匿名内部类的语法规则看上去有些古怪，不过如同匿名数组一样，当你只需要创建一个类的对象而且用不上它的名字时，使用内部类可以使代码看上去简洁清楚。它的语法规则是这样的：
new interfacename(){......}; 或 new superclassname(){......};
     下面接着前面继续举例子：
  1. public class Goods3 {  
  2.     public Contents cont() {  
  3.         return new Contents() {  //Contents是接口
  4.             private int i = 11;  
  5.             public int value() {  
  6.                 return i;  
  7.             }  
  8.         };  
  9.     }  
  10. }  
     这里方法cont()使用匿名内部类直接返回了一个实现了接口Contents的类的对象，看上去的确十分简洁。
在java的事件处理的匿名适配器中，匿名内部类被大量的使用。例如在想关闭窗口时加上这样一句代码：
  1. frame.addWindowListener(new WindowAdapter(){  
  2.     public void windowClosing(WindowEvent e){  
  3.        System.exit(0);  
  4.     }  
  5. });   
     有一点需要注意的是，匿名内部类由于没有名字，所以它没有构造函数（但是如果这个匿名内部类继承了一个只含有带参数构造函数的父类，创建它的时候必须带上这些参数，并在实现的过程中使用super关键字调用相应的内容）。
【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/weilf/p/4113479.html