java内部类InnerClass的总结
java允许在类中再声明类，称为内部类(InnerClass)。
具体而言，内部类分为：
<非静态内部类>：声明为其外部类的成员
<静态内部类>：声明为其外部类的成员
<局部内部类>：声明在代码块中
<匿名内部类>：声明在代码块中
------------------非静态内部类non-static InnerClass------------------
非静态内部类：没有static修饰的内部类。
非静态内部类使用规则：
1.不能声明静态成员(成员变量、方法)，除非使用final static将成员变量声明为常量。
2.不能内嵌静态内部类。
3.可以使用private、protected修饰
使用非静态内部类的意义主要有以下几点：
1.内部类可以实现类的隐藏。
对于普通的非内部类只能使用public、默认包权限，而内部类可以使用private修饰符隐藏自己，
若再配合private构造方法、接口和外部类方法可以更好的实现内部类的隐藏。
代码如下：
interface AboutWeight {
final int TARGET_WEIGHT = 800;
int getWeight();
void controlWeight();
}
interface AboutFatRate {
final double TARGET_FAT_RATE = 0.6;
double getFatRate();
void controlFatRate();
}
class Pigs {
private int currentWeight;
private double currentFatRate;
private class PigAW implements AboutWeight {
private int 催肥激素量;
private void 喂催肥激素(int diff) {
currentWeight += 催肥激素量;
}
public int getWeight() {
return currentWeight;
}
public void controlWeight() {
if (currentWeight < TARGET_WEIGHT) {
催肥激素量 = TARGET_WEIGHT - currentWeight;
喂催肥激素(催肥激素量);
System.out.println("纯天然饲料喂养。");
} else {
System.out.println("已达到目标重量，无需加天然饲料。");
}
}
private PigAW(int x) {
currentWeight = x;
}
}
private class PigAF implements AboutFatRate {
private int 瘦肉精量;
private int isFat() {
if (currentFatRate > TARGET_FAT_RATE)
return 1;
else {
if (currentFatRate == TARGET_FAT_RATE)
return 0;
else
return -1;
}
}
private void 喂瘦肉精(int diff) {
currentFatRate -= diff * currentWeight;
}
public double getFatRate() {
return currentFatRate;
}
public void controlFatRate() {
if (isFat() == 1) {
瘦肉精量 = (int) (currentFatRate - TARGET_FAT_RATE) * currentWeight;
喂瘦肉精(瘦肉精量);
System.out.println("通过运动，肥肉已变成瘦肉。");
} else if (isFat() == 0)
System.out.println("肥瘦正合适");
else if (isFat() == -1)
System.out.println("需增肥");
}
private PigAF(double x) {
currentFatRate = x;
}
}
public AboutWeight weight(int x) {// 方法weight()，返回类型为接口类型AboutWeight
return new PigAW(x);
}
public AboutFatRate fat(double x) {// 方法fat()，返回类型为接口类型AboutFatRate
return new PigAF(x);
}
}
class TestPigs {
public static void main(String[] args) {
Pigs p = new Pigs();
AboutWeight w = p.weight(120);/*
* AboutWeightw
* 将变量w申明为AboutWeight类型的引用，
* 指向其实现类PigAW的对象(这里只看到方法)
*/
AboutFatRate f = p.fat(0.8);
}
}类的隐藏所需要的条件包括：
1)私有内部类；
2)私有内部类实现了某个接口(若不实现接口，则内部类对象在其他类中无法声明类型。接口就相当于内部类的超类。)
3)外部类有public方法返回接口类型的内部类对象
如果将PigAF声明为protected，那么可以用Pigs.PigAF来声明PigAF的引用变量，但因为PigAF的构造方法是private的，所以无法使用new创建对象。
如果将PigAF的构造方法声明为public、protected、默认包权限，则可以在其他类中使用new创建PigAF对象(但必须使用outerObject.new)。
在外部类以外的其他类中创建未隐藏的内部类对象的方法是：
outerObjectReference=new outerClassName(ConstructorParameters);
outerClass.innerClass innerObjectReference=outerObject.new InnerClassName(ConstructorParameters);
注意：
1)必须先创建外部类对象，才能创建内部类对象。因为内部类对象是绑定在特定的外部类对象上的。后面详述。
2)即使内部类和其构造方法为public/默认包权限/protected权限，也必须使用外部类的对象的new方法创建内部类对象
outerClass.innerClass a=outerObject.new innerClass(ConstructorParam)，而不能使用
outerClass.innerClass a=new outerClass.innerClass(Constructor_ParamList)，原因同注1。
3)外部类对象可以创建无数个内部类对象绑定在自身。
2.非静态内部类可以无限制的访问外部类的所有成员，包括私有成员
非静态内部类的另一个用途就是可以访问外部类的所有成员(任意权限的成员变量、方法)。
上例中可以看到内部类访问了private currentWeight和private currentFatRate，外部类的private方法也一样能访问(示例中未定义外部类的private方法)。
这个特性在某些时候可能很有用。
内部类对象之所以能够访问外部类对象所有成员的原因在于：非静态内部类对象保存着其外部类对象的引用。
JAVA在创建非静态内部类对象innerClass obj_B=new innerClass(constructorParam)时，会“隐式地”把外部类对象outerClass obj_A=new outerClass(constructorParam)的引用obj_A传给obj_B并一直保存在obj_B中(obj_A仅仅是为了好看，实际传递的是outerClass.this)，也就是所谓的内部类对象绑定在外部类对象上，从而使得内部类对象始终可以访问外部类对象。
因此必须先创建外部类对象，再创建内部类对象。
附注for2：
当然外部类对象也可以访问内部类的所有成员。
外部类在访问内部类非静态成员变量、方法前需要创建内部类对象，通过内部类对象来引用。
如果外部类和内部类存在同名的成员变量或方法：
1)外部类访问内部类同名成员规则同上，
2)内部类访问外部类同名成员则需要使用outerClass.this.成员变量名/方法名。(outerClass.this就是外部类的引用)
代码示例：
class Pigs {
private int currentWeight;
private double currentFatRate;
PigAW objPigAW;
int i;
public void Output(){
objPigAW=new PigAW(100);//访问内部类的成员变量前，需创建对象
objPigAW.i=10;
objPigAW.喂催肥激素(objPigAW.i);
objPigAW.j=20;
}
private class PigAW implements AboutWeight {
int i;//与外部类int i 同名
int j;
private int 催肥激素量;
private void OutPut(){//与外部类OutPut()同名
System.out.println("我是内部类");
}
private void 喂催肥激素(int diff) {
currentWeight += 催肥激素量;
Pigs.this.i=10;//outerClass.this.成员变量名调用外部类同名成员变量；
Pigs.this.Output();//outerClass.this.方法名调用外部类同名方法
}
........................
........................
3.内部类可以间接的实现多重继承
这个特性应该是内部类存在的最大理由之一，它间接的实现了多重继承，使得Java的继承机制更加完善。
Java中类只能单继承类，多重继承则是依靠实现多个接口来完成。但实现接口时可能比较麻烦，比如实现接口就必须实现它的所有方法，这样需要实现很多不必要的方法。
而使用内部类可以使我们的类继承多个类(实例类或抽象类)，我们只需要通过重写或隐藏以得到适合自己的方法即可。
示例如下：
class Example1 {
public String name() {
return "liutao";
}
}
class Example2 {
public int age() {
return 25;
}
}
class MainExample {
private class test1 extends Example1 {
public String name() {
return super.name();
}
}
private class test2 extends Example2 {
public int age() {
return super.age();
}
}
public String name() {
return new test1().name();
}
public int age() {
return new test2().age();
}
public static void main(String args[]) {
MainExample mi = new MainExample();
System.out.println("姓名:" + mi.name());
System.out.println("年龄:" + mi.age());
}
}
MainExample类的内部类test1类继承了Example1，test2继承了Example2，这样类MainExample就拥有了Example1和Example2的方法和属性，如前面所说，外部类可以访问内部类的所有成员，从而间接地实现了多继承。
4. 避免修改接口而实现同一个类中两种同名方法的调用。
假设类B要继承一个类A的同时还要实现一个接口K，且类A和接口K存在同名方法method()，那么子类B中的的public method()方法到底是实现了接口方法还是重写/隐藏了类A的方法呢？如下例，类EatChild的bite()方法到底是重写了类Eat的bite()方法还是实现了接口Eatbale的bite()方法，说不清楚。
interface Eatable {
void bite();
}
class Eat {
public void bite() {
System.out.println("bite me");
}
}
class EatChild extends Eat implements Eatable {
public void bite() {
System.out.println("Who am I?");
}
}一般的做法是修改接口的方法名，但如果接口已经广泛使用，则修改量可能很大。
而内部类则可以不用修改接口方法名同时有效的解决这个问题。
代码示例：
interface Eatable {
void bite();
}
class Eat {
public void bite() {
System.out.println("bite me");
}
}
class EatChild extends Eat {
private class InnerEatChild implements Eatable {
public void bite() {
System.out.println("I am an implementor.");
}
}
public Eatable innerObj(){
return new InnerEatChild();
}
}
让外部类来继承超类，内部类来实现接口，即可解决。
------------------静态内部类static InnerClass------------------
java中并没有独立存在的static静态类，所有的静态类都必须以内部类的形式存在。
静态内部类使用规则：
1.只能定义于顶层外部类或其它静态内部类中（嵌套定义）------------------要么是第1层级静态内部类，要么是多层静态内部类嵌套。
2.可以内嵌非静态内部类或静态内部类。
3.可以声明实例成员和静态成员(成员变量、方法)。-----------------非静态内部类是不能包含静态成员的。
4.只能直接访问外部类的静态成员(成员变量、方法)，若要访问外部类的非静态成员须先创建外部类对象。---------与普通的静态方法规则类似，只不过这里是类而不是方法
5.不能使用outerClass.this作为外部类的引用。----------------这是与非静态内部类本质上的区别。此规则也跟静态方法比较类似(不能使用this，super)
非静态内部类中没有外部类的引用，也导致了它不能访问外部类的非静态成员(没有绑定到外部类实例上)。
6.如果非静态内部类可以被外部类以外的其他类可见(如非private)，使用时，不需要创建外部类对象。------理由同5
outerClass.staticInnerClass.staticMemberVariable=20;
outerClass.staticInnerClass a=new outerClass.staticInnerClass(ConstructorParam);静态内部类使用得较少，其存在的意义有：(前3点与非静态内部类一样的，如果不是必须包含静态成员，那完全可以用非静态内部类代替)
1.静态内部类也可以实现自身的隐藏，操作方法与非静态内部类相同；
2.与非静态内部类一样，间接的实现多重继承；
3.与非静态内部类一样，不修改接口方法名同时完成继承和实现接口；
4.提供主方法满足java的编译需要(我觉得这个有些牵强，似乎没有减少什么代码量)；
在进行代码单元测试时，如果在每一个Java源文件中都设置一个main()方法，那么会出现很多额外的代码。而且这段主方法对于Java文件来说只是一个形式，其本身并不需要这种主方法。但是少了这个主方法又不行。在这种情况下，就可以将主方法写入到静态内部类中以满足编译需要。
5.某些时候内部类需要定义成静态内部类。
比如某个内部类必须使用静态成员时，那没办法。
------------------局部内部类local innerClass------------------
还有一种特殊的内部类，它与非静态内部类相似，但又有不同，因此属于单独的一种内部类。
顾名思义，局部内部类与局部变量差不多，它存在于代码块code block中。
示例如下：
存在于代码块中的局部内部类
class Goods1 {
public Destination dest(String s) {
class GDestination implements Destination { //存在于方法体中
private String label;
private GDestination(String whereTo) {
label = whereTo;
}
public String readLabel() {
return label;
}
}
return new GDestination(s);
}
public static void main(String[] args) {
Goods1 g = new Goods1();
Destination d = g.dest("Beijing");
}
} 这样也可以。
public class Goods2 {
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) {
Goods2 g = new Goods2();
g.track();
}
}局部内部类不能使用任何的访问权限修饰符，唯一能使用的两个修饰符是final和abstract(当然不需要可以不用)，
否则编译出错，它的作用域一般都被限制在它所在的代码块中。
局部内部类有两个特点：
1.它对外面的所有类来说都是隐藏的，哪怕是它所属的外部类，仅有它所在的方法知道它；
2.它不仅可以访问它所属外部类中的数据，还可以访问它所在的code block的局部变量和方法参数，不过局部变量和参数必须声明为final类型。
------------------匿名内部类anonymous InnerClass------------------
匿名内部类存在的意义是：
当你只需要创建一个类的对象而不需要使用它的名字时，使用匿名内部类可以使代码看上去简洁清楚。
class Goods3 {
public AboutWeight cont() {
return new AboutWeight() {
private int i = 11;
public int value() {
return i;
}
public int getWeight() {
return i;
}
public void controlWeight() {
return;
}
};
}
}匿名内部类的语法如下：
new interfacename(){......};
或
new superclassname(){......};注意：new后面跟的是接口名或超类名，你需要在{}类体中实现接口方法或继承超类。
在java的事件处理的匿名适配器中，匿名内部类被大量使用。例如在想关闭窗口时加上这样一句代码：
frame.addWindowListener(
new WindowAdapter(){
public void windowClosing(WindowEvent e){
System.exit(0);
}
}
);
注意：
匿名内部类也只能访问它所在的代码块的final局部变量。
匿名内部类由于没有名字，所以它没有构造函数。
（但是如果这个匿名内部类的超类只含有带参构造方法，创建它的时候必须带上相应参数，并在实现的过程中使用super调用相应的内容）。
如果你想要初始化它的成员变量，有如下方法：
1)如果匿名内部类在一个方法内，可以利用这个方法传进你想要的参数，不过这些参数必须被声明为final。
2)将匿名内部类改造成有名字的局部内部类，这样它就可以拥有构造函数了。
3)在这个匿名内部类中使用初始化代码块。