第五话-依赖倒转原则



哎。真是纠结。

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("
2012年我电脑的内存坏了，我又买了一个4G的装上了");
		JsdMemory4g memory = new JsdMemory4g();
		c1.setMemory(memory);
		c1.show();
		System.out.println("
2013年我又买了一台笔记本，请看參数：");
		Computer c2 = new Computer("华硕", new HsBoard(), new IntelCpui5(), new JsdMemory2g());
		c2.show();
		System.out.println("
可是我的华硕本的内存太小了，我把我后来买的那个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就要到了哦。