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

	}
}

示例中，非静态内部类PigAW和PigAF声明为private，要访问它们只能通过外部类Pigs类的public方法weight()和fat()所创建的内部类对象w和f来完成，weight()和fat()返回的对象类型是内部类所实现的接口类型。由此导致其他类连它们的类名都无法得知，通过对象f和w唯一能使用的就是内部类对象所实现的接口的public方法。

类的隐藏所需要的条件包括：
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();
    }
}

其实上例是有问题的，当b不成立时，下面的new和方法访问显然要出事，不过编译能通过(说实话，我不太明白为啥，对编译原理不了解)

局部内部类不能使用任何的访问权限修饰符，唯一能使用的两个修饰符是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;
			}
		};
	}
}

这里方法cont()使用匿名内部类直接返回了一个实现了接口AboutWeight的类的对象，看上去的确十分简洁。

匿名内部类的语法如下：

new interfacename(){......}; 
或 
new superclassname(){......};

注意：new后面跟的是接口名或超类名，你需要在{}类体中实现接口方法或继承超类。

在java的事件处理的匿名适配器中，匿名内部类被大量使用。例如在想关闭窗口时加上这样一句代码：

frame.addWindowListener(
        new WindowAdapter(){
            public void windowClosing(WindowEvent e){
              System.exit(0); 
            }
           }
        );

注意：

匿名内部类也只能访问它所在的代码块的final局部变量。

匿名内部类由于没有名字，所以它没有构造函数。

（但是如果这个匿名内部类的超类只含有带参构造方法，创建它的时候必须带上相应参数，并在实现的过程中使用super调用相应的内容）。

如果你想要初始化它的成员变量，有如下方法：

1)如果匿名内部类在一个方法内，可以利用这个方法传进你想要的参数，不过这些参数必须被声明为final。
2)将匿名内部类改造成有名字的局部内部类，这样它就可以拥有构造函数了。
3)在这个匿名内部类中使用初始化代码块。