设计模式（1）-设计模式的七大原则（一）

设计模式的目的

编写软件过程中，程序员面临着来自 耦合性，内聚性以及可维护性，可扩展性，重
用性，灵活性 等多方面的挑战，设计模式是为了让程序(软件)，具有更好

1. 代码重用性 (即：相同功能的代码，不用多次编写)
2. 可读性 (即：编程规范性, 便于其他程序员的阅读和理解)
3. 可扩展性 (即：当需要增加新的功能时，非常的方便，称为可维护)
4. 可靠性 (即：当我们增加新的功能后，对原来的功能没有影响)
5. 使程序呈现高内聚，低耦合的特性

设计模式的七大原则

设计模式原则，其实就是程序员在编程时，应当遵守的原则，也是各种设计模式的基础**(即：设计模式为什么这样设计的依据)**
1) 单一职责原则
2) 接口隔离原则
3) 依赖倒转(倒置)原则
4) 里氏替换原则
5) 开闭原则
6) 迪米特法则
7) 合成复用原则

七大原则逐一介绍

1.单一职责原则

基本介绍
对类来说的，即一个类应该只负责一项职责。如类A负责两个不同职责：职责1，职责2。当职责1需求变更而改变A时，可能造成职责2执行错误，所以需要将类A的粒度分解为 A1，A2

应用实例
我们以交通工具案例进行说明，简单的所单一职责原则就是要做到类、方法的各司其职。查看下面三个代码的run方法。

1. SingleResponsibility1.java

/**
 * 	title:七大原则之单一职责原则
 * 	data：2020.3.21
 */

package principle.singleresponsibility;

public class SingleResponsibility1 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Vehicle vehicek = new Vehicle();
		vehicek.run("摩托车");
		vehicek.run("小汽车");
		vehicek.run("飞机");
	}

}

//方式一分析
/**
 * 1.在方式一的run中，违反了单一职责原则
 * 2.解决方案非常简单，根据交通滚局运行方法不同，分解成不同的类即可
 * 
 * @author dall
 *
 */

//交通工具类
class Vehicle{
	public void run(String vehicle) {
		System.out.println(vehicle+"在公路上行驶。。。");
	}
}

2. SingleResponsibility2.java

/**
 * 	title:七大原则之单一职责原则
 * 	data：2020.3.21
 */

package principle.singleresponsibility;

public class SingleResponsibility2 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		RoadVehicel roadVehicel = new RoadVehicel();
		roadVehicel.run("摩托车");
		
		AirVehicel airVehicel = new AirVehicel();
		airVehicel.run("飞机");
		
		WaterVehicel waterVehicel = new WaterVehicel();
		waterVehicel.run("游艇");
	}

}
//方案二分析：
/**
 * 1.遵守了单一职责原则
 * 2.但是这样的改动答大，即需要将类分解，同时修改客户端
 * 3.改进：直接修改Vehicel类，改动的代码就会比较少=》方案3
 * @author dall
 *
 */


//陆地上的交通工具
class RoadVehicel{
	public void run(String vehicle) {
		System.out.println(vehicle+"在公路上行驶。。。");
	}
}

//空中交通工具
class AirVehicel{
	public void run(String vehicle) {
		System.out.println(vehicle+"在天空行驶。。。");
	}
}

//水中交通工具
class WaterVehicel{
	public void run(String vehicle) {
		System.out.println(vehicle+"在水中行驶。。。");
	}
}

3. .SingleResponsibility3.java

package principle.singleresponsibility;

public class SingleResponsibility3 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Vehicle2 vehicek2 = new Vehicle2();
		vehicek2.run("摩托车");
		vehicek2.runWater("游艇");
		vehicek2.runAir("飞机");
	}

}
//方式三分析
/**
 * 1.这种修改灭与偶对原来的类做大的修改，只是增加方法
 * 2.虽然没有在类这个级别上遵守单一职责原则，但是在方法级别上遵守了单一职责原则
 * @author dall
 *
 */

//交通工具类
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+"在水中上行驶。。。");
	}
}

分析

1. 在方式一的run中，违反了单一职责原，.解决方案非常简单，根据交通滚局运行方法不同，分解成不同的类即可
2. .方式二遵守了单一职责原则，但是这样的改动答大，即需要将类分解，同时修改客户端，改进：直接修改Vehicel类，改动的代码就会比较少=》方案3
3. 方式三这种修没有对原来的类做大的修改，只是增加方法，虽然没有在类这个级别上遵守单一职责原则，但是在方法级别上遵守了单一职责原则

单一职责原则注意事项和细节

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

2.接口隔离原则(Interface Segregation Principle)

基本介绍
客户端不应该依赖它不需要的接口，即一个类对另一个类的依赖应该建立在最小的接口上
看实例：

1.类A通过接口Interface1依赖类B，类C通过接口Interface1依赖类D，如果接口Interface1对于类A和类C来说不是最小接口，那么类B和类D必须去实现他们不需要的方
法。
2. 按隔离原则应当这样处理：将接口Interface1拆分为独立的几个接口，类A和类C分别与他们需要的接口建立依赖关系。也就是采用接口隔离原则

应传统方法的问题和使用接口隔离原则改进

1.类A通过接口Interface1依赖类B，类C通过接口Interface1依赖类D，如果接口Interface1对于类A和类C来说不是最小接口，那么类B和类D必须去实现他们不需要的方法
2.将接口Interface1拆分为独立的几个接口，类A和类C分别与他们需要的接口建立依赖关系。也就是采用接口隔离原则
3. 接口Interface1中出现的方法，根据实际情况拆分为三个接口
4.代码实现
**原先的代码：**Segregation1.java

package segregation;


public class Segregation1 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

	}

}
interface Interface1 {
	void peration1();
	void peration2();
	void peration3();
	void peration4();
	void peration5();
	
}

class B implements Interface1{
	public void peration1() {
		System.out.println("B实现了peration1");
	}
	public void peration2() {
		System.out.println("B实现了peration2");
	}
	public void peration3() {
		System.out.println("B实现了peration3");
	}
	public void peration4() {
		System.out.println("B实现了peration4");
	}
	public void peration5() {
		System.out.println("B实现了peration5");
	}
}

class D implements Interface1{
	public void peration1() {
		System.out.println("D实现了peration1");
	}
	public void peration2() {
		System.out.println("D实现了peration2");
	}
	public void peration3() {
		System.out.println("D实现了peration3");
	}
	public void peration4() {
		System.out.println("D实现了peration4");
	}
	public void peration5() {
		System.out.println("D实现了peration5");
	}
}

class A{//A类通过接口Interface1依赖（使用）B类，但是只会用到1  2   3方法
	public void depend1(Interface1 i) {
		i.peration1();
		i.peration2();
		i.peration3();
		
	}
}

class C{//A类通过接口Interface1依赖（使用）B类，但是只会用到1 4 5方法
	public void depend1(Interface1 i) {
		i.peration1();
		i.peration4();
		i.peration5();
		
	}
}

**修改后的代码：**Segregation1.java

package improve;

public class Segregation1 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		A a = new A();
		a.depend1(new B());//A类通过接口去依赖B类
		a.depend2(new B());
		a.depend3(new B());

	}

}
interface Interface1 {
	void peration1();
	
}

interface Interface2 {
	
	void peration2();
	void peration3();
	
}

interface Interface3 {
	void peration4();
	void peration5();
	
}

class B implements Interface1,Interface2{
	public void peration1() {
		System.out.println("B实现了peration1");
	}
	public void peration2() {
		System.out.println("B实现了peration2");
	}
	public void peration3() {
		System.out.println("B实现了peration3");
	}
}

class D implements Interface1,Interface3{
	public void peration1() {
		System.out.println("D实现了peration1");
	}
	public void peration4() {
		System.out.println("D实现了peration4");
	}
	public void peration5() {
		System.out.println("D实现了peration5");
	}
}

class A{//A类通过接口Interface1依赖（使用）B类，但是只会用到1  2   3方法
	public void depend1(Interface1 i) {
		i.peration1();
	
	}
	public void depend2(Interface2 i) {
		i.peration2();
	
	}
	public void depend3(Interface2 i) {
		i.peration3();
	
	}
}

class C{//A类通过接口Interface1依赖（使用）B类，但是只会用到1 4 5方法
	public void depend1(Interface1 i) {
		i.peration1();
		
	}
	public void depend2(Interface3 i) {
		i.peration4();
		
	}
	public void depend3(Interface3 i) {
		i.peration4();
		
	}
}

3.依赖倒转原则

基本介绍
依赖倒转原则(Dependence Inversion Principle)是指：

1. 高层模块不应该依赖低层模块，二者都应该依赖其抽象
2. 抽象不应该依赖细节，细节应该依赖抽象
3. 依赖倒转(倒置)的中心思想是面向接口编程
4. 依赖倒转原则是基于这样的设计理念：相对于细节的多变性，抽象的东西要稳定的
   多。以抽象为基础搭建的架构比以细节为基础的架构要稳定的多。在java中，抽象
   指的是接口或抽象类，细节就是具体的实现类
5. 使用接口或抽象类的目的是制定好规范，而不涉及任何具体的操作，把展现细节的
   任务交给他们的实现类去完成

应用实例

1. 请编程完成Person 接收消息 的功能。
2. 实现方案1 + 分析说明

package inversion;

public class DependcyInversion {

	public static void main(String[] args) {
	Persion per = new Persion();
	per.receive(new Email());

	}

}
class Email{
	public String getInfo() {
		return "电子邮件信息：hello word！！";
	}
}

//完成persoin接受接收消息的功能
//方式一 分析
/**
 * 1.简单，比较容易想到
 * 2.如果我们获取的对象是微信、短信等，则要新增类，同时Persion也要增加同样的方法
 * 3.解决思路：引入一个抽象接口，IReceiver，这样Persion与接口发生依赖
 * 		因为Email、微信等都属于接受者的范围，他们各自实现IReceiver接口，就符合依赖倒转原则
 * @author dall
 *
 */
class Persion{
	public void receive(Email email) {
		System.out.println(email.getInfo());
	}
	
}

3. 实现方案2 + 分析说明

package inversion.improve;

public class DependcyInversion {

	public static void main(String[] args) {
	//客户端无需改变
	Persion per = new Persion();
	per.receive(new Email());
	per.receive(new WeiXin());
	
	}

}

//定义一个接口
interface IReceiver{
	public String getInfo();
}

class Email implements IReceiver{
	
	@Override
	public String getInfo() {
		
		return "电子邮件信息：hello word！！";
	}
}

//增加微信
class WeiXin implements IReceiver{
	@Override
	public String getInfo() {
		
		return "微信信息：hello ok！！";
	}
}
//方式2
class Persion{
	//这里我们是对于接口的依赖
	public void receive(IReceiver receiver) {
		System.out.println(receiver.getInfo());
	}
	
}

依赖关系传递的三种方式

1. 接口传递
2. 构造方法传递
3. setter方法传递