3、设计模式之软件设计原则

3. 软件设计原则

设计模式原则，其实就是程序员在编程时，应当遵守的原则，也是各种设计模式的基础(即:设计模式为什么这样设计的依据)

设计模式常用的七大原则有:

• 单一职责原则
• 接口隔离原则
• 依赖倒转(倒置)原则
• 里氏替换原则
• 开闭原则.
• 迪米特法则.
• 合成复用原则

下面开始对各个原则进行介绍，并使用代码结合来理解

3.1 单一职责原则

3.1.1 基本介绍

单一职责原则（Single Responsibility Principle）是对类来说的，即一个类应该只负责一项职责。 如类A负责两个不同职责:职责1,职责2。当职责1需求变更而改变A时，可能造成职责2执行错误，所以需要将类A的粒度分解为A1, A2。

3.1.2 应用示例

以交通工具案例说明

• 原始方案

public class SingleResponsibility1 {

	public static void main(String[] args) {
		
		Vehicle vehicle = new Vehicle();
		vehicle.run("摩托车");
		vehicle.run("火车");
		vehicle.run("飞机");
		vehicle.run("轮船");
	}
}
// 交通工具类
// 违法单一职责原则，该类此时负责的包括陆地，空中和水中的交通工具，
// 这显然已经违背了单一职责原则
class Vehicle {
	public void run(String vehicle) {
		System.out.println(vehicle + "在陆地上运行...");
	}
}

Vehicle 类此时负责的包括陆地，空中和水中的交通工具，这已经违背了单一职责原则

• 第一种修改方案：将原始方案工具交通方式的分解为不同的类即可

public class SingleResponsibility2 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		RoadVehicle roadVehicle = new RoadVehicle();
		roadVehicle.run("摩托车");
		roadVehicle.run("高铁");
		
		AirVehicle airVehicle = new AirVehicle();
		airVehicle.run("飞机");
		
		WaterVehicle waterVehicle = new WaterVehicle();
		waterVehicle.run("轮船");
	}

}

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 + "在水中运行...");
	}
}

RoadVehicle负责陆地的，AirVehicle负责空中的，WaterVehicle负责水中的，但是我们的功能是很简单的，把Vehicle分解为三个类真的有必要吗？

• 第二种修改方案：直接修改 Vehicle 类

public class SingleResponsibility3 {

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

}

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）这种修改方法没有对原来的类做大的修改，只是增加方法

2）这里虽然没有在类这个级别上遵守单一职责原则，但是在方法级别上，仍然是遵守单一职责

3.1.3 单一职责原则总结

1. 降低类的复杂度，一个类只负责一项职责
2. 提高类的可读性，可维护性
3. 降低变更引起的风险

通常情况下，我们应当遵守单一职责原则，只有在逻辑足够简单的情况下，才可以在代码级违反单一职责原则;只有类中方法数量足够少，可以在方法级别保持单一职责原则

3.2 接口隔离原则

3.2.1 基本介绍

接口隔离原则（Interface Segregation Principle）描述的是客户端不应该依赖它不需要的接口，即一个类对另一个类的依赖应该建立在最小的接口上，通俗一点就是拆分接口中的方法使其成为最小接口。

先看看下面这个类图：

• 问题

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

3.2.2 应用示例

上图中对应的代码为：

public class Segregation1 {

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

	}

}

interface Interface1 {
	void operation1();
	void operation2();
	void operation3();
	void operation4();
	void operation5();
}

class B implements Interface1 {
	@Override
	public void operation1() {
		System.out.println("B实现了 operation1");
	}
	@Override
	public void operation2() {
		System.out.println("B实现了 operation2");		
	}
	@Override
	public void operation3() {
		System.out.println("B实现了 operation3");
	}
	@Override
	public void operation4() {
		System.out.println("B实现了 operation4");
	}
	@Override
	public void operation5() {
		System.out.println("B实现了 operation5");
	}
}

class D implements Interface1 {
	@Override
	public void operation1() {
		System.out.println("D实现了 operation1");
	}
	@Override
	public void operation2() {
		System.out.println("D实现了 operation2");		
	}
	@Override
	public void operation3() {
		System.out.println("D实现了 operation3");
	}
	@Override
	public void operation4() {
		System.out.println("D实现了 operation4");
	}
	@Override
	public void operation5() {
		System.out.println("D实现了 operation5");
	}
}


class A {
	public void dependence1(Interface1 i) {
		i.operation1();
	}
	public void dependence2(Interface1 i) {
		i.operation2();
	}
	public void dependence3(Interface1 i) {
		i.operation3();
	}
}

class C {
	public void dependence1(Interface1 i) {
		i.operation1();
	}
	public void dependence4(Interface1 i) {
		i.operation4();
	}
	public void dependence5(Interface1 i) {
		i.operation5();
	}
}

3.2.3 使用接口隔离原则改进

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

使用接口隔离原则改进上图，改进后的类图和代码如下：

改进后的代码：

public class Segregation2 {

	public static void main(String[] args) {
		
		A a = new A();
		a.dependence1(new B());
		a.dependence2(new B());
		a.dependence3(new B());
		
		C c = new C();
		c.dependence1(new D());
		c.dependence4(new D());
		c.dependence5(new D());
		
	}

}

interface Interface1 {
	void operation1();
}
interface Interface2 {
	void operation2();
	void operation3();
}
interface Interface3 {
	void operation4();
	void operation5();
}

class B implements Interface1, Interface2 {

	@Override
	public void operation1() {
		System.out.println("B重写了方法 1");
	}
	@Override
	public void operation2() {
		System.out.println("B重写了方法 2");
	}
	@Override
	public void operation3() {
		System.out.println("B重写了方法 3");
	}
}
class D implements Interface1, Interface3 {

	@Override
	public void operation1() {
		System.out.println("D重写了方法 1");
	}
	@Override
	public void operation4() {
		System.out.println("D重写了方法 4");
	}
	@Override
	public void operation5() {
		System.out.println("D重写了方法 5");
	}
}

class A {
	public void dependence1(Interface1 i) {
		i.operation1();
	}
	public void dependence2(Interface2 i) {
		i.operation2();
	}
	public void dependence3(Interface2 i) {
		i.operation3();
	}
}

class C {
	public void dependence1(Interface1 i) {
		i.operation1();
	}
	public void dependence4(Interface3 i) {
		i.operation4();
	}
	public void dependence5(Interface3 i) {
		i.operation5();
	}
}

3.3 依赖倒转(倒置)原则

3.3.1 基本介绍

依赖倒转原则（Dependence Inversion Principle）是指：

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

3.3.2 应用实例1

组装电脑：现要组装一台电脑，需要配cpu，硬盘，内存条。只有这些配置都有了，计算机才能正常的运行。选择cpu有很多选择，如Intel，AMD等，硬盘可以选择希捷，西数等，内存条可以选择金士顿，海盗船等。类图和对应的代码如下：

public class Inversion1 {

	public static void main(String[] args) {
		
		Computer computer = new Computer();
		computer.setCpu(new InterCpu());
		computer.setDisk(new XiJieHardDisk());
		computer.setMemory(new KingstonMemory());
		
		computer.run();

	}

}

class XiJieHardDisk {
	public void save(String data) {
		System.out.println("希捷硬盘保存数据");
	}
	public String get() {
		return "希捷硬盘：hello";
	}
}

class InterCpu {
	public void run() {
		System.out.println("Inter CPU开始运行");
	}
}

class KingstonMemory {
	public void save(String data) {
		System.out.println("金士顿内存保存数据");
	}
}

class Computer {
	private XiJieHardDisk disk;
	private InterCpu cpu;
	private KingstonMemory memory;
	
	public void setDisk(XiJieHardDisk disk) {
		this.disk = disk;
	}

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

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

	public void run() {
		System.out.println("计算机开始工作");
		cpu.run();
		memory.save("hello");
		System.out.println("从硬盘中获取的数据：" + disk.get());
	}
	
}

• 问题：如果我们要使用的CPU是AMD的，或者要使用的内存是三星的，则需要新增它们各自的类，同时Computer类也要增加相应的方法。
• 解决思路：引入CPU、内容和硬盘各自的抽象接口，使Computer与接口发生依赖，而不是与具体的类发生依赖。
• 修改后的类图和对应的代码如下
  组装电脑的改进后的类图

对应代码如下：

// 测试
public class Inversion {

	public static void main(String[] args) {
		
		Computer computer = new Computer();
		computer.setCpu(new InterCpu());
		computer.setDisk(new XiJieHardDisk());
		computer.setMemory(new KingstonMemory());
		computer.run();
		
		Computer computer2 = new Computer();
		computer2.setCpu(new AMDCpu());
		computer2.setDisk(new WDHardDisk());
		computer2.setMemory(new SanXingMemory());
		computer2.run();
	}

}

interface Cpu {
	void run();
}

interface Memory {
	void save(String data);
}

interface HardDisk {
	void save(String data);
	String get();
}

class XiJieHardDisk implements HardDisk {

	@Override
	public void save(String data) {
		System.out.println("希捷硬盘保存数据");
	}
	
	@Override
	public String get() {
		return "希捷硬盘：hello";
	}
}

class WDHardDisk implements HardDisk {

	@Override
	public void save(String data) {
		System.out.println("西数硬盘保存数据");
	}
	
	@Override
	public String get() {
		return "西数硬盘：haha";
	}
}

class KingstonMemory implements Memory {

	@Override
	public void save(String data) {
		System.out.println("金士顿内存保存数据");
	}
}

class SanXingMemory implements Memory {
	@Override
	public void save(String data) {
		System.out.println("三星内存保存数据");
	}
}

class InterCpu implements Cpu {

	@Override
	public void run() {
		System.out.println("Inter CPU开始运行");
	}
}
class AMDCpu implements Cpu {
	@Override
	public void run() {
		System.out.println("AMD CPU开始运行");
	}
}

class Computer {
	
	private Memory memory;
	private HardDisk disk;
	private Cpu cpu;
	
	public void setMemory(Memory memory) {
		this.memory = memory;
	}
	
	public void setDisk(HardDisk disk) {
		this.disk = disk;
	}
	
	public void setCpu(Cpu cpu) {
		this.cpu = cpu;
	}
	
	public void run() {
		System.out.println("计算机开始工作");
		cpu.run();
		memory.save("hello");
		System.out.println("从硬盘中获取的数据：" + disk.get());
	}
}

3.3.3 应用示例2

Person 接收消息的功能，对应的代码如下：

public class Inversion2 {

	public static void main(String[] args) {
		Person person = new Person();
		person.receive(new Email());
	}

}

class Email {
	public void getMsg(String msg) {
		System.out.println("电子邮件信息：" + msg);
	}
}

class Person {
	public void receive(Email email) {
		email.getMsg("哈哈哈");
	}
}

• 问题：如果我们获取的对象是微信，短信等等，则新增类，同时Perons也要增加相应的接收方法
• 解决思路：引入一个抽象的接口IReceiver表示接收者,这样Person类与接口IReceiver发生依赖，因为Email,WeiXin等等属于接收的范围，他们各自实现IReceiver接口就可以了,这样我们就符号依赖倒转原则。
  示例2初始代码的改进

public class Iversion2 {

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

}


interface IReceiver {
	public void getMsg(String msg);
}

class WeChat implements IReceiver {

	@Override
	public void getMsg(String msg) {
		System.out.println("微信接收到信息：" + msg);
	}
}

class Email implements IReceiver {

	@Override
	public void getMsg(String msg) {
		System.out.println("电子邮件接收到信息：" + msg);
	}
}

class Person {
	public void receive(IReceiver receiver) {
		receiver.getMsg("hello");
	}
}

3.3.4 依赖传递的三种方式

依赖传递的三种方式：接口传递、构造方法传递和setter方式传递
对这三种方式的的理解需要对面向对象程序设计具有一定基础。

• 接口方式实现依赖传递：

public class DependencyPass {

	public static void main(String[] args) {
		OpenAndClose openAndClose = new OpenAndClose();
		openAndClose.open(new ChangHong());
	}

}

interface ITV {
	void play();
}

interface IOpenAndClose {
	void open(ITV tv);
}

class ChangHong implements ITV {

	@Override
	public void play() {
		System.out.println("长虹电视机开机");
	}
}

class OpenAndClose implements IOpenAndClose {

	@Override
	public void open(ITV tv) {
		tv.play();		
	}
	
}

• 构造方法实现依赖传递

public class DependencyPass {

	public static void main(String[] args) {		
		// 构造方法方式
		OpenAndClose openAndClose = new OpenAndClose(new ChangHong());
		openAndClose.open();
	}

}
// 构造方法传递
interface ITV {
	void play();
}

interface IOpenAndClose {
	void open();
}
class OpenAndClose implements IOpenAndClose {
	private ITV tv;
	public OpenAndClose(ITV tv) {
		this.tv = tv;
	}
	@Override
	public void open() {
		tv.play();		
	}
	
}
class ChangHong implements ITV {

	@Override
	public void play() {
		System.out.println("长虹电视机开机");
	}
}

• setter方式实现依赖传递：

public class DependencyPass {

	public static void main(String[] args) {
		// setter 方法方式
		OpenAndClose openAndClose = new OpenAndClose();
		openAndClose.setTv(new ChangHong());
		openAndClose.open();
	}

}
interface ITV {
	void play();
}

interface IOpenAndClose {
	void open();
}
class OpenAndClose implements IOpenAndClose {
	private ITV tv;
	
	public void setTv(ITV tv) {
		this.tv = tv;
	}

	@Override
	public void open() {
		tv.play();		
	}
	
}
class ChangHong implements ITV {

	@Override
	public void play() {
		System.out.println("长虹电视机开机");
	}
}

3.3.5 依赖倒置原则总结

1. 低层模块尽量都要有抽象类或接口，或者两者都有，程序稳定性更好.
2. 变量的声明类型尽量是抽象类或接口，这样我们的变量引用和实际对象间，就存在一个缓冲层，利于程序扩展和优化
3. 继承时遵循里氏替换原则

3.4 里氏替换原则

OO中继承性的思考和说明

1. 继承包含这样一层含义：父类中凡是已经实现好的方法，实际上是在设定规范和契约，虽然它不强制要求所有的子类必须遵循这些契约，但是如果子类对这些已经实现的方法任意修改，就会对整个继承体系造成破坏。
2. 继承在给程序设计带来便利的同时，也带来了弊端。比如使用继承会给程序带来侵入性，程序的可移植性降低，增加对象间的耦合性，如果一个类被其他的类所继承，则当这个类需要修改时，必须考虑到所有的子类，并且父类修改后，所有涉及到子类的功能都有可能产生故障
3. 问题提出：在编程中，如何正确的使用继承? => 里氏替换原则（Liskov Substitution Principle）

3.4.1 基本介绍

1. 子类继承父类时，除添加新的方法完成新增功能外，尽量不要重写父类的方法
2. 如果通过重写父类的方法来完成新的功能，这样写起来虽然简单，但是整个继承体系的可复用性会比较差，特别是运用多态比较频繁时，程序运行出错的概率会非常大
3. 里氏替换原则告诉我们，继承实际上让两个类耦合性增强了，在适当的情况下，可以通过聚合、组合、依赖来解决问题

3.4.2 看一段代码

• 代码如下：

package d1_principles.t5_liskov;

public class LiskovSubstitution {

	public static void main(String[] args) {
		
		A a = new A();
		a.fun();
		System.out.println("3 - 6 = " + a.fun1(3, 6));
		System.out.println("8 - 4 = " + a.fun1(8, 4));
		
		// 程序员2此时还不知道fun1方法已被重写，
		B b = new B();
		b.fun();
		System.out.println("1 - 3 = " + b.fun1(1, 3));
		System.out.println("2 - 5 = " + b.fun1(2 , 5));
	}

}

class A {
	public void fun() {
		System.out.println("A.fun()");
	}
	// 返回两个数的差
	public int fun1(int a, int b) {
		return a - b;
	}
}

// B 类继承 A，并新增了一个功能
class B extends A {
	// 可能此时程序1还没有意识到已经在重写父类中的方法了（多个程序员共同维护）
	public int fun1(int a, int b) {
		return a + b;
	}
	public int fun2(int a, int b) {
		return fun1(a, b) * 10;
	}
}

以上代码对应的类图如下：

3.4.3 改进

1. 我们发现原来运行正常的相减功能发生了错误。原因就是类B无意中重写了父类的方法，造成原有功能出现错误。在实际编程中，我们常常会通过重写父类的方法完成新的功能，这样写起来虽然简单，但整个继承体系的复用性会比较差。特别是运行多态比较频繁的时候。
2. 通用的做法是：原来的父类和子类都继承一个更通俗的基类，原有的继承关系去掉，采用依赖，聚合，组合等关系代替

• 类图如下：
  
• 对应代码如下:

package d1_principles.t5_liskov.improve;


public class LiskovSubstitution {

	public static void main(String[] args) {
		A a = new A();
		a.fun();
		System.out.println("3 - 6 = " + a.fun1(3, 6));
		System.out.println("8 - 4 = " + a.fun1(8, 4));
		
		// 程序员2此时还不知道fun1方法已被重写，
		B b = new B();
		b.fun();
		System.out.println("1 + 3 = " + b.fun1(1, 3));
		System.out.println("2 + 5 = " + b.fun1(2 , 5));
	}

}
// 创建一个更加基础的类，把基础的成员写到其中
class Base {
	public void fun() {
		System.out.println("Base.fun()");
	}
}

class A extends Base {
	// 返回两个数的差
	public int fun1(int a, int b) {
		return a - b;
	}
}

class B extends Base {
	private A a = new A();
	// 返回两个数的和
	public int fun1(int a, int b) {
		return a + b;
	}
	public int fun2(int a, int b) {
		return fun1(a, b) * 10;
	}
	// 继续使用 A 中的方法
	public int fun3(int a, int b) {
		return this.a.fun1(a, b);
	}
}

3.5 开闭原则

3.5.1 基本介绍

1. 开闭原则（Open Closed Principle）是编程中最基础、最重要的设计原则。
2. 一个软件实体，如类、模块和函数应该对扩展开放(对提供方)，对修改关闭(对使用方)。用抽象构建框架，用实现扩展细节。
3. 当软件需要变化时，尽量通过扩展软件实体的行为来实现变化，而不是通过修改已有的代码来实现变化。

3.5.2 看一段代码

• 一个画图的功能：
  类图如下：
  
• 对应代码如下：

package d1_principles.t1_ocp;

public class OpenClosed {

   public static void main(String[] args) {
   	
   	GraphicEditor editor = new GraphicEditor();
   	editor.drawShape(new Rectangle());
   	editor.drawShape(new Circle());
   	
   }
}
// 图形类
class Shape {
   int m_type;
}
// 长方形
class Rectangle extends Shape {
   public Rectangle() {
   	m_type = 1;
   }
}
// 圆形
class Circle extends Shape {
   public Circle() {
   	m_type = 2;
   }
}
// 画图 - [使用者]
class GraphicEditor {
   public void drawShape(Shape shape) {
   	// 根据类型不同来画图
   	if ( shape.m_type == 1 ) {
   		drawRetangle(shape);
   	} else if ( shape.m_type == 2 ) {
   		drawCircle(shape);
   	}
   }
   
   private void drawRetangle(Shape shape) {
   	System.out.println("绘制长方形");
   }
   
   private void drawCircle(Shape shape) {
   	System.out.println("绘制圆形");
   }
}

• 此时如果我们需要画一个三角形，则需要对上述的代码做出如下调整：

package d1_principles.t1_ocp;

public class OpenClosed {

	public static void main(String[] args) {
		
		GraphicEditor editor = new GraphicEditor();
		editor.drawShape(new Rectangle());
		editor.drawShape(new Circle());
		editor.drawShape(new Triangle());
	}

}
// 图形类
class Shape {
	int m_type;
}
// 长方形
class Rectangle extends Shape {
	public Rectangle() {
		m_type = 1;
	}
}
// 圆形
class Circle extends Shape {
	public Circle() {
		m_type = 2;
	}
}
class Triangle extends Shape {
	public Triangle() {
		m_type = 3;
	}
}
// 画图 - [使用者]
class GraphicEditor {
	public void drawShape(Shape shape) {
		// 根据类型不同来画图
		if ( shape.m_type == 1 ) {
			drawRetangle(shape);
		} else if ( shape.m_type == 2 ) {
			drawCircle(shape);
		} else if ( shape.m_type == 3 ) {
			drawTriangle(shape);
		}
	}
	
	private void drawRetangle(Shape shape) {
		System.out.println("绘制长方形");
	}
	
	private void drawCircle(Shape shape) {
		System.out.println("绘制圆形");
	}
	
	private void drawTriangle(Shape shape) {
		System.out.println("绘制三角形");
	}
}

做出的改变有：新增一个三角形的图形类，还要在 GraphicEditor 中修改代码并新增方法，这显然已经违背了开闭原则（只做扩展不做修改）

3.5.3 改进

思路：把创建Shape类做成抽象类，并提供一个抽象的draw方法，让子类去实现即可，这样我们有新的图形种类时，只需要让新的图形类继承Shape，并实现draw方法即可，使用方的代码就不需要修 满足了开闭原则，代码如下：

package d1_principles.t1_ocp.improve;


public class OpenClosed {

	public static void main(String[] args) {
		GraphicEditor editor = new GraphicEditor();
		editor.drawShape(new Rectangle());
		editor.drawShape(new Circle());
		editor.drawShape(new Triangle());
	}

}

abstract class Shape {
	int m_type;
	public abstract void drawShape();
}
//长方形
class Rectangle extends Shape {
	public Rectangle() {
		m_type = 1;
	}

	@Override
	public void drawShape() {
		System.out.println("绘制长方形");	
	}
}
//圆形
class Circle extends Shape {
	public Circle() {
		m_type = 2;
	}

	@Override
	public void drawShape() {
		System.out.println("绘制圆形");
	}
}
class Triangle extends Shape {
	public Triangle() {
		m_type = 3;
	}

	@Override
	public void drawShape() {
		System.out.println("绘制三角形");
	}
	
}
//画图 - [使用者]
class GraphicEditor {
	public void drawShape(Shape shape) {
		shape.drawShape();
	}
}

• 对应类图如下：
  
• 此时如果我们需要画一个五角星，则需要对上面的代码 做出如下调整：

package d1_principles.t1_ocp.improve;


public class OpenClosed {

	public static void main(String[] args) {
		GraphicEditor editor = new GraphicEditor();
		editor.drawShape(new Rectangle());
		editor.drawShape(new Circle());
		editor.drawShape(new Triangle());
		editor.drawShape(new FiveShape());
	}

}

abstract class Shape {
	int m_type;
	public abstract void drawShape();
}
//长方形
class Rectangle extends Shape {
	public Rectangle() {
		m_type = 1;
	}

	@Override
	public void drawShape() {
		System.out.println("绘制长方形");	
	}
}
//圆形
class Circle extends Shape {
	public Circle() {
		m_type = 2;
	}

	@Override
	public void drawShape() {
		System.out.println("绘制圆形");
	}
}
class Triangle extends Shape {
	public Triangle() {
		m_type = 3;
	}

	@Override
	public void drawShape() {
		System.out.println("绘制三角形");
	}
	
}
class FiveShape extends Shape {
	public FiveShape() {
		m_type = 4;
	}

	@Override
	public void drawShape() {
		System.out.println("绘制五角星");
	}
}
//画图 - [使用者]
class GraphicEditor {
	public void drawShape(Shape shape) {
		shape.drawShape();
	}
}

此时我们只需要扩展一个五角星实体即可，不用对其他代码进行修改，就满足了开闭原则 只做扩展，不做修改

3.6 迪米特法则

3.6.1 基本介绍

1. 迪米特法则(Demeter Principle)又叫最少知道原则，即一个类对自己依赖的类知道的越少越好。也就是说，对于被依赖的类不管多么复杂，都尽量将逻辑封装在类的内部。对外除了提供的public方法，不对外泄露任何信息。其目的是降低类之间的耦合度，提高模块的相对独立性。
2. 迪米特法则还有个更简单的定义:只与直接朋友通信
3. 直接朋友:每个对象都会与其他对象有耦合关系，只要两个对象之间有耦合关系，我们就说这两个对象之间是朋友关系。耦合的方式很多，依赖，关联，组合，聚合等。其中，我们称出现在成员变量，方法参数，方法返回值中的类为直接的朋友，而出现在局部变量中的类不是直接的朋友。也就是说，陌生的类最好不要以局部变量的形式出现在类的内部。

3.6.2 应用实例

• 明星与经纪人的关系实例：明星由于全身心投入艺术，所以许多日常事务由经纪人负责处理，如和粉丝的见面会，和媒体公司的业务洽淡等。这里的经纪人是明星的朋友，而粉丝和媒体公司是陌生人，所以适合使用迪米特法则。
• 类图如下：
  
• 代码如下:

package d1_principles.t6_demeter;

public class Demiter {

	public static void main(String[] args) {
		Agent agent = new Agent();
		agent.setCompany(new Company("明星公司"));
		agent.setFan(new Fan("张三"));
		agent.setStar(new Star("张三丰"));
		
		agent.business();
		agent.metting();
	}

}

class Star {
	private String name;
	public Star(String name) {
		this.name = name;
	}
	public String getName() {
		return name;
	}
}
class Fan {
	private String name;
	public Fan(String name) {
		this.name = name;
	}
	public String getName() {
		return name;
	}
}
class Company {
	private String name;
	public Company(String name) {
		this.name = name;
	}
	public String getName() {
		return name;
	}
}
class Agent {
	private Star star;
	private Fan fan;
	private Company company;
	
	public void setStar(Star star) {
		this.star = star;
	}
	public void setFan(Fan fan) {
		this.fan = fan;
	}
	public void setCompany(Company company) {
		this.company = company;
	}
	
	public void metting() {
		System.out.println(fan.getName() + "与明星" + star.getName() + "见面了。");
	}
	public void business() {
        System.out.println(company.getName() + "与明星" + star.getName() + "洽淡业务。");
    }
	
}

3.6.3 小结

1. 迪米特法则的核心是降低类之间的耦合
2. 但是注意:由于每个类都减少了不必要的依赖，因此迪米特法则只是要求降低类间(对象间)耦合关系，并不是要求完全没有依赖关系

3.7 合成复用原则

通常类的复用分为继承复用和合成复用两种。
继承复用虽然有简单和易实现的优点，但它也存在以下缺点：

1. 继承复用破坏了类的封装性。因为继承会将父类的实现细节暴露给子类，父类对子类是透明的，所以这种复用又称为“白箱”复用。
2. 子类与父类的耦合度高。父类的实现的任何改变都会导致子类的实现发生变化，这不利于类的扩展与维护。
3. 它限制了复用的灵活性。从父类继承而来的实现是静态的，在编译时已经定义，所以在运行时不可能发生变化。

采用组合或聚合复用时，可以将已有对象纳入新对象中，使之成为新对象的一部分，新对象可以调用已有对象的功能，它有以下优点：

1. 它维持了类的封装性。因为成分对象的内部细节是新对象看不见的，所以这种复用又称为“黑箱”复用。
2. 对象间的耦合度低。可以在类的成员位置声明抽象。
3. 复用的灵活性高。这种复用可以在运行时动态进行，新对象可以动态地引用与成分对象类型相同的对象。

例：汽车分类管理程序

• 汽车按“动力源”划分可分为汽油汽车、电动汽车等；按“颜色”划分可分为白色汽车、黑色汽车和红色汽车等。如果同时考虑这两种分类，其组合就很多。类图如下：
  
  上面类图我们可以看到使用继承复用产生了很多子类，如果现在又有新的动力源或者新的颜色的话，就需要再定义新的类。我们试着将继承复用改为聚合复用看一下。
  

相关文章索引

设计模式概述
UML类图

---

后记

我水平有限，错误难免，还望各位加以指正。

---

本文内容到此结束，感谢您的阅读！！！如果内容对你有帮助的话，记得给我三连丫（点赞、收藏、关注）