设计模式 7原则

1.单一职责

单一职责，顾名思义，一个类只负责一个职责。

例如：
一个交通类。

class Vehicle {
	public void run(String vehicle) {
		System.out.println(vehicle + " 在公路上运行....");
	}
}

交通方式有很多，很显然这个不符合单一职责。

那么怎么改呢？
有两种
第一种，创建更多的类，用不同的类封装不同的方法。
显然这么做的代价太大。

class RoadVehicle {
	public void run(String vehicle) {
		System.out.println(vehicle + "公路运行");
	}
}

class AirVehicle {
	public void run(String vehicle) {
		System.out.println(vehicle + "天空运行");
	}
}

class WaterVehicle {
	public void run(String vehicle) {
		System.out.println(vehicle + "水中运行");
	}
}

第二种
直接修改方法即可。

class Vehicle2 {
	public void run(String vehicle) {
		//处理
		
		System.out.println(vehicle + " 在公路上运行....");
		
	}
	
	public void runAir(String vehicle) {
		System.out.println(vehicle + " 在天空上运行....");
	}
	
	public void runWater(String vehicle) {
		System.out.println(vehicle + " 在水中行....");
	}
	
	//方法2.
	//..
	//..
	
	//...
}

总结一下。
1)降低类的复杂度，一个类只负责一项职责。
2)提高类的可读性，可维护性
3)降低变更引起的风险
4)通常情况下，我们应当遵守单一职责原则，只有逻辑足够简单，才可以在代码级违

2.接口隔离

接口隔离，本质上和单一职责差不多。
大概就是将接口中的方法做到最小化，也就是每个接口中的方法没有冗余。
不用去实现多余的方法，如果我们先要去实现其他的方法，只要实现多个接口就可以，

例如： 类c，要实现接口a中的123方法，类b要实现接口b的456方法，类c要实现345方法。
这时候，就要把12封装成一个接口，45封装成一个接口，6封装成一个接口，就类似与这种。
就是接口隔离。

3.依赖倒转

这个就更简单了，跟上面两个也很类似，不过更接近面向对象。
总结一句话，细节依赖抽象。
也就是说，我们的实现类去实现抽象类中的方法，就像多了一个缓冲层一样，你只要在缓冲层完成方法的定义，具体的细节再交由实现类来实现。

具体的例子如下：
实现一个 开关电视的功能，首先有一个电视类，然后电视类里面有开电视的方法，当然这个肯定是接口，具体的实现需要交由具体的电视去实现。
整个具体的电视类，如长虹电视，实现其电视接口，然后实现方法。

interface IOpenAndClose {
	public void open(); // 抽象方法

	public void setTv(ITV tv);
}

interface ITV { // ITV接口
	public void play();
}

class OpenAndClose implements IOpenAndClose {
	private ITV tv;

	public void setTv(ITV tv) {
		this.tv = tv;
	}

	public void open() {
		this.tv.play();
	}
}

class ChangHong implements ITV {

	@Override
	public void play() {
		// TODO Auto-generated method stub
		System.out.println("长虹电视机，打开");
	}
	 
}

4.里氏替换

这个可以理解为将类中的共性抽取出来，在封装一层。

5.开闭原则

开闭原则，对扩展开放（开发），对修改关闭（使用）。

6.迪米特法则

迪米特法则(Demeter Principle)又叫最少知道原则，即一个类对自己依赖的类知道的越少越好。也就是说，对于被依赖的类不管多么复杂，都尽量将逻辑封装在类的内部。对外除了提供的public 方法，不对外泄露任何信息。

7.合成复用原则

原则是尽量使用合成/聚合的方式，而不是使用继承