为什么需要内部类

终于把内部类看完了。或许我们不禁要问，为什么需要内部类，或使用内部类有什么好处。
下面我使用以下几点来总结内部类到底有什么好处。

1.可以实现隐藏和组织代码的模式

public class Sequence {

	private String[] contents;

	public Sequence(String[] contents) {
		this.contents = contents;
	}

	public class Content{
		private int idx;

		private String getCurrent(){
			return contents[idx];
		}

		private String next(){
			if(idx<contents.length-1)
				return contents[++idx];
			return null;
		}

		private String prev(){
			if(idx>0)
				return contents[--idx];
			return null;
		}
	}

	public Content first(){
		Content content = new Content();
		content.idx = 0;
		return content;
	}

	public Content last(){
		Content content = new Content();
		content.idx = contents.length-1;
		return content;
	}

	public static void main(String[] args) {
		Sequence sequence = new Sequence(new String[]{"1","5","9","30","99","100"});
		Content c = sequence.last();
		do{
			System.out.println(c.getCurrent());
		}while(c.prev()!=null);
	}

}

上面这段代码可以实现数组的正向和反向的遍历。对于使用者来说不需要知道内部是怎么实现遍历那部分内容，因此可以把这部分代码放在内部类里隐藏起来。

2.实现闭包与回调的功能

package com.unis.innerclass;

public class Anoymous {
	public static void main(String[] args) {
		String zzg ="zzg";
		executeCommand(new Command(){
			@Override
			public void execute(Object obj) {
				System.out.println(obj);
			}
		},zzg);
	}
	private static void executeCommand(Command command,Object obj){
		command.execute(obj);
	}
}

interface Command{
	void execute(Object obj);
}

上面这种使用方式在很多场合中也会用到。

3.实现事件驱动模型

package com.unis.innerclass;
interface Excute{
	void doExcute();
}
public class Operation {
	private Excute exec;
	private int number1;
	private int number2;
	public int getNumber1() {
		return number1;
	}
	public void setNumber1(int number1) {
		this.number1 = number1;
	}
	public int getNumber2() {
		return number2;
	}
	public void setNumber2(int number2) {
		this.number2 = number2;
	}
	public void add(){
		exec = new Excute(){
			@Override
			public void doExcute() {
				number1 = number1+number2;
				number2 = 0;
			}
		};
	}
	public void oper(){
		exec.doExcute();
	}
	public static void main(String[] args) {
		Operation o = new Operation();
		o.setNumber1(10);
		o.add();
		o.setNumber2(20);
		o.oper();
		System.out.println(o.getNumber1());
	}

}

上面这段代码模拟了计算器的一个功能。

4.内部类与控制框架

package com.unis.innerclass;

interface Button{
	void doSomething();
}

class Light{
	public void on(){
		System.out.println("灯开");
	}
	public void off(){
		System.out.println("灯关");
	}
}
class AirCondition{
	public void on(){
		System.out.println("空调开");
	}
	public void off(){
		System.out.println("空调关");
	}
}

public class RemoteControl {
	private Light light = new Light();
	private AirCondition aircondition = new AirCondition();
	Button[] b ={
		new Button(){
			@Override
			public void doSomething() {
				light.on();
			}
		},
		new Button(){
			@Override
			public void doSomething() {
				light.off();
			}
		},
		new Button(){
			@Override
			public void doSomething() {
				aircondition.on();
			}
		},
		new Button(){
			public void doSomething() {
				aircondition.off();
			}
		}
	};

	public void click(int i){
		if(i>=4){
			throw new RuntimeException("操作错误");
		}
		b[i].doSomething();
	}

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		RemoteControl r = new RemoteControl();
		r.click(3);
	}

}

上面这段代码其实就是实现了一个按键操作，对于按不同的键来实现灯开，灯关，空调开，空调关的操作。

5.解决多重继承问题

package com.unis.innerclass;
class D{

}
abstract class E{

}
class Z extends D{
	E makeE(){
		return new E(){

		};
	}
}

public class MutiImplementation {
	static void takesD(D d){};
	static void takesE(E e){};
	public static void main(String[] args) {
		Z z = new Z();
		takesD(z);
		takesE(z.makeE());
	}

}