第五话-依赖倒转原则

前端之家收集整理的这篇文章主要介绍了第五话-依赖倒转原则前端之家小编觉得挺不错的,现在分享给大家,也给大家做个参考。

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

@H_301_2@运行结果:

@H_301_2@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("是不是很灵活,懂了么?依赖倒转原则");
	}
}
@H_301_2@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();
	}
}
@H_301_2@Board.java

public interface Board {
	public void showBoard();
}
@H_301_2@cpu.java

public interface cpu {
	public void showcpu();
}
@H_301_2@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内存条");
	}

}
@H_301_2@三、小结和建议

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

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

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

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

猜你在找的设计模式相关文章