哎，真是纠结。2011年买的笔记本，2G内存，320G硬盘，i3处理器。现在用着好卡呀。呜呜。怎么办？买个新的吧太贵了，5K呀。还好，可以买个4G内存，再买个1T硬盘。加起来顶多1K哦，同样感受飞一般的感觉。太好了。
可是，我2012年买的手机好卡呀。配置好低呀。呜呜，iphone6都出了。4G时代都流行了，NFC功能爽歪歪。哎，只好换了！
为什么电脑可以换零件，手机就不能呢？这是因为，Computer在设计时非常注重面向对象的思想哦。这就是面向对象的好处。
那么什么才是真正的面向对象呢？那就充分体现在依赖倒转原则上。
一、什么是依赖倒转原则呢？
依赖倒转原则：抽象不应该依赖细节，细节应该依赖于抽象。也就是说，要针对接口编程，不要针对实现编程。
还不懂么？那就试着想一下，那么多电脑生产厂家，如果每一家都有自家的一套方案。同一家的电脑才能使用同一家的零件。那么，你的电脑如果是华硕，那么你就只能用华硕的主板，用华硕的内存条（假如公司生产这些东西）。当你又买了一个新电脑是联想的，那么你之前的电脑的内存条，硬盘什么的不就报废了么？
还好电脑是这样设计的：电脑有一个抽象的规则，不去限制细节实现。这样只要各生产厂家遵从此抽象规则，就可以相互使用了。多好。
还不懂？上代码。
二、代码（电脑系统）

运行结果：

Main.java

public class Main {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		System.out.println("2011年我买了一台笔记本，请看参数：");
		Computer c1 = new Computer("联想", new LxBoard(), new IntelCpui3(), new JsdMemory2g());
		c1.show();
		System.out.println("\n2012年我电脑的内存坏了，我又买了一个4G的装上了");
		JsdMemory4g memory = new JsdMemory4g();
		c1.setMemory(memory);
		c1.show();
		System.out.println("\n2013年我又买了一台笔记本，请看参数：");
		Computer c2 = new Computer("华硕", new HsBoard(), new IntelCpui5(), new JsdMemory2g());
		c2.show();
		System.out.println("\n但是我的华硕本的内存太小了，我把我后来买的那个4G内存拔出来换到里面不就OK了");
		c2.setMemory(c1.getMemory());
		c2.show();
		System.out.println("是不是很灵活，懂了么？依赖倒转原则");
	}
}

Computer.java

Computer.java
public class Computer {
	private String name;
	private Board board;
	private Cpu cpu;
	private Memory memory;

	public Computer(String name) {
		this.name = name;
	}

	public Computer(String name, Board board, Cpu cpu, Memory memory) {
		this.name = name;
		this.board = board;
		this.cpu = cpu;
		this.memory = memory;
	}

	public void setBoard(Board board) {
		this.board = board;
	}

	public void setCpu(Cpu cpu) {
		this.cpu = cpu;
	}

	public void setMemory(Memory memory) {
		this.memory = memory;
	}

	public Board getBoard() {
		return board;
	}

	public Cpu getCpu() {
		return cpu;
	}

	public Memory getMemory() {
		return memory;
	}

	public void show() {
		System.out.println("我是" + name + "牌子的电脑，我现在的电脑配置如下：");
		board.showBoard();
		cpu.showCpu();
		memory.showMemory();
	}
}

Board.java

public interface Board {
	public void showBoard();
}

Cpu.java

public interface Cpu {
	public void showCpu();
}

Memory.java

public interface Memory {
	public void showMemory();
}

HsBoard.java
public class HsBoard implements Board {
	public void showBoard() {
		// TODO Auto-generated method stub
		System.out.println("我是华硕主板");
	}

}

LxBoard.java
public class LxBoard implements Board {
	public void showBoard() {
		// TODO Auto-generated method stub
		System.out.println("我是联想主板");
	}

}

IntelCpui3.java
public class IntelCpui3 implements Cpu {
	public void showCpu() {
		// TODO Auto-generated method stub
		System.out.println("我是因特尔的CPU，我是酷睿i3");
	}

}

IntelCpui5.java
public class IntelCpui5 implements Cpu {
	public void showCpu() {
		// TODO Auto-generated method stub
		System.out.println("我是因特尔的CPU，我是酷睿i5");
	}

}

JsdMemory2g.java
public class JsdMemory2g implements Memory {
	public void showMemory() {
		// TODO Auto-generated method stub
		System.out.println("我是金士顿2g内存条");
	}

}

三、小结和建议

对于依赖倒转原则，只要时刻记住面向接口编程（实际中可以使用接口，或者抽象类实现），而非面向细节编程就可以了。依赖倒转主要是说明，高层模块不应该依赖底层模块，两个都应该依赖抽象。

还是那句话，面向对象编程，时刻记住：可维护，可复用，可扩展，很灵活。

对之前做个总结，记住他们的名字：简单工厂模式，策略模式，单一职责原则，开放封闭原则，依赖倒转原则。

建议，没有女朋友的ITer兄弟们，赶紧行动，11.11就要到了哦。

第五话-依赖倒转原则