3，软件设计原则

在软件开发中，为了提高软件系统的可维护性和可复用性，增加软件的可扩展性和灵活性，程序员要尽量根据6条原则来开发程序，从而提高软件开发效率、节约软件开发成本和维护成本。

3.1 开闭原则

对扩展开放，对修改关闭。在程序需要进行拓展的时候，不能去修改原有的代码，实现一个热插拔的效果。简言之，是为了使程序的扩展性好，易于维护和升级。

想要达到这样的效果，我们需要使用接口和抽象类。

因为抽象灵活性好，适应性广，只要抽象的合理，可以基本保持软件架构的稳定。而软件中易变的细节可以从抽象派生来的实现类来进行扩展，当软件需要发生变化时，只需要根据需求重新派生一个实现类来扩展就可以了。

下面以 搜狗输入法 的皮肤为例介绍开闭原则的应用。

【例】搜狗输入法 的皮肤设计。

分析：搜狗输入法 的皮肤是输入法背景图片、窗口颜色和声音等元素的组合。用户可以根据自己的喜爱更换自己的输入法的皮肤，也可以从网上下载新的皮肤。这些皮肤有共同的特点，可以为其定义一个抽象类（AbstractSkin），而每个具体的皮肤（DefaultSpecificSkin和HeimaSpecificSkin）是其子类。用户窗体可以根据需要选择或者增加新的主题，而不需要修改原代码，所以它是满足开闭原则的。

/*** @author zzyuan* @date 2022/4/27 - 11:07* 抽象皮肤类**/
public abstract class AbstractSkin {//显示的方法public abstract void display();}

/*** @author zzyuan* @date 2022/4/27 - 11:09* 默认皮肤类**/
public class DefaultSkin extends AbstractSkin {@Overridepublic void display() {System.out.println("默认皮肤");}
}


/*** @author zzyuan* @date 2022/4/27 - 11:10*/
public class HeiMaSkin extends AbstractSkin {@Overridepublic void display() {System.out.println("黑马皮肤");}}

/*** @author zzyuan* @date 2022/4/27 - 11:11* 搜狗输入法*/
public class SougouInput {private AbstractSkin skin;public void setSkin(AbstractSkin skin) {this.skin = skin;}public void display(){skin.display();}}

/*** @author zzyuan* @date 2022/4/27 - 11:13*/
public class Client {public static void main(String[] args) {SougouInput input = new SougouInput();//1.创建皮肤对象DefaultSkin skin = new DefaultSkin();input.setSkin(skin);//展示input.display();HeiMaSkin heiMaSkin = new HeiMaSkin();input.setSkin(heiMaSkin);//展示input.display();//需求：扩展一个传智皮肤ChuanZhiSkin chuanZhiSkin = new ChuanZhiSkin();input.setSkin(chuanZhiSkin);input.display();}
}

/*** @author zzyuan* @date 2022/4/27 - 11:16*/
public class ChuanZhiSkin extends AbstractSkin{@Overridepublic void display() {System.out.println("传智皮肤");}
}

3.2 里氏代换原则

里氏代换原则是面向对象设计的基本原则之一。

里氏代换原则：任何基类可以出现的地方，子类一定可以出现。
通俗理解：子类可以扩展父类的功能，但不能改变父类原有的功能。
换句话说，子类继承父类时，除添加新的方法完成新增功能外，尽量不要重写父类的方法。

如果通过重写父类的方法来完成新的功能，这样写起来虽然简单，但是整个继承体系的可复用性会比较差，特别是运用多态比较频繁时，程序运行出错的概率会非常大。

下面看一个里氏替换原则中经典的一个例子

【例】正方形不是长方形。

在数学领域里，正方形毫无疑问是长方形，它是一个长宽相等的长方形。所以，我们开发的一个与几何图形相关的软件系统，就可以顺理成章的让正方形继承自长方形。

代码如下：

长方形类（Rectangle）：

public class Rectangle {private double length;private double width;public double getLength() {return length;}public void setLength(double length) {this.length = length;}public double getWidth() {return width;}public void setWidth(double width) {this.width = width;}
}

正方形（Square）：

由于正方形的长和宽相同，所以在方法setLength和setWidth中，对长度和宽度都需要赋相同值。

public class Square extends Rectangle {public void setWidth(double width) {super.setLength(width);super.setWidth(width);}public void setLength(double length) {super.setLength(length);super.setWidth(length);}
}

类RectangleDemo是我们的软件系统中的一个组件，它有一个resize方法依赖基类Rectangle，resize方法是RectandleDemo类中的一个方法，用来实现宽度逐渐增长的效果。

public class RectangleDemo {public static void resize(Rectangle rectangle) {while (rectangle.getWidth() <= rectangle.getLength()) {rectangle.setWidth(rectangle.getWidth() + 1);}}//打印长方形的长和宽public static void printLengthAndWidth(Rectangle rectangle) {System.out.println(rectangle.getLength());System.out.println(rectangle.getWidth());}public static void main(String[] args) {Rectangle rectangle = new Rectangle();rectangle.setLength(20);rectangle.setWidth(10);resize(rectangle);printLengthAndWidth(rectangle);System.out.println("============");Rectangle rectangle1 = new Square();rectangle1.setLength(10);resize(rectangle1);printLengthAndWidth(rectangle1);}
}

我们运行一下这段代码就会发现，假如我们把一个普通长方形作为参数传入resize方法，就会看到长方形宽度逐渐增长的效果，当宽度大于长度,代码就会停止，这种行为的结果符合我们的预期；假如我们再把一个正方形作为参数传入resize方法后，就会看到正方形的宽度和长度都在不断增长，代码会一直运行下去，直至系统产生溢出错误。所以，普通的长方形是适合这段代码的，正方形不适合。
我们得出结论：在resize方法中，Rectangle类型的参数是不能被Square类型的参数所代替，如果进行了替换就得不到预期结果。因此，Square类和Rectangle类之间的继承关系违反了里氏代换原则，它们之间的继承关系不成立，正方形不是长方形。

如何改进呢？此时我们需要重新设计他们之间的关系。抽象出来一个四边形接口(Quadrilateral)，让Rectangle类和Square类实现Quadrilateral接口

3.3 依赖倒转原则

高层模块不应该依赖低层模块，两者都应该依赖其抽象；
抽象不应该依赖细节，细节应该依赖抽象。
简单的说就是要求对抽象进行编程，不要对实现进行编程，这样就降低了客户与实现模块间的耦合。

下面看一个例子来理解依赖倒转原则

【例】组装电脑

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

代码如下：

希捷硬盘类（XiJieHardDisk）:

public class XiJieHardDisk implements HardDisk {public void save(String data) {System.out.println("使用希捷硬盘存储数据" + data);}public String get() {System.out.println("使用希捷希捷硬盘取数据");return "数据";}
}

Intel处理器（IntelCpu）：

public class IntelCpu implements Cpu {public void run() {System.out.println("使用Intel处理器");}
}

金士顿内存条（KingstonMemory）：

public class KingstonMemory implements Memory {public void save() {System.out.println("使用金士顿作为内存条");}
}

电脑（Computer）：

public class Computer {private XiJieHardDisk hardDisk;private IntelCpu cpu;private KingstonMemory memory;public IntelCpu getCpu() {return cpu;}public void setCpu(IntelCpu cpu) {this.cpu = cpu;}public KingstonMemory getMemory() {return memory;}public void setMemory(KingstonMemory memory) {this.memory = memory;}public XiJieHardDisk getHardDisk() {return hardDisk;}public void setHardDisk(XiJieHardDisk hardDisk) {this.hardDisk = hardDisk;}public void run() {System.out.println("计算机工作");cpu.run();memory.save();String data = hardDisk.get();System.out.println("从硬盘中获取的数据为：" + data);}
}

测试类（TestComputer）：

测试类用来组装电脑。

public class TestComputer {public static void main(String[] args) {Computer computer = new Computer();computer.setHardDisk(new XiJieHardDisk());computer.setCpu(new IntelCpu());computer.setMemory(new KingstonMemory());computer.run();}
}

上面代码可以看到已经组装了一台电脑，但是似乎组装的电脑的cpu只能是Intel的，内存条只能是金士顿的，硬盘只能是希捷的，这对用户肯定是不友好的，用户有了机箱肯定是想按照自己的喜好，选择自己喜欢的配件。

根据依赖倒转原则进行改进：

代码我们只需要修改Computer类，让Computer类依赖抽象（各个配件的接口），而不是依赖于各个组件具体的实现类。

类图如下：

电脑（Computer）：

public class Computer {private HardDisk hardDisk;private Cpu cpu;private Memory memory;public HardDisk getHardDisk() {return hardDisk;}public void setHardDisk(HardDisk hardDisk) {this.hardDisk = hardDisk;}public Cpu getCpu() {return cpu;}public void setCpu(Cpu cpu) {this.cpu = cpu;}public Memory getMemory() {return memory;}public void setMemory(Memory memory) {this.memory = memory;}public void run() {System.out.println("计算机工作");}
}

面向对象的开发很好的解决了这个问题，一般情况下抽象的变化概率很小，让用户程序依赖于抽象，实现的细节也依赖于抽象。即使实现细节不断变动，只要抽象不变，客户程序就不需要变化。这大大降低了客户程序与实现细节的耦合度。

3.4 接口隔离原则

客户端不应该被迫依赖于它不使用的方法；一个类对另一个类的依赖应该建立在最小的接口上。

下面看一个例子来理解接口隔离原则

【例】安全门案例

我们需要创建一个黑马品牌的安全门，该安全门具有防火、防水、防盗的功能。可以将防火，防水，防盗功能提取成一个接口，形成一套规范。类图如下：

上面的设计我们发现了它存在的问题，黑马品牌的安全门具有防盗，防水，防火的功能。现在如果我们还需要再创建一个传智品牌的安全门，而该安全门只具有防盗、防水功能呢？很显然如果实现SafetyDoor接口就违背了接口隔离原则，那么我们如何进行修改呢？看如下类图：

代码如下：

AntiTheft（接口）：

public interface AntiTheft {void antiTheft();
}

Fireproof（接口）：

public interface Fireproof {void fireproof();
}

Waterproof（接口）：

public interface Waterproof {void waterproof();
}

HeiMaSafetyDoor（类）：

public class HeiMaSafetyDoor implements AntiTheft,Fireproof,Waterproof {public void antiTheft() {System.out.println("防盗");}public void fireproof() {System.out.println("防火");}public void waterproof() {System.out.println("防水");}
}

ItcastSafetyDoor（类）：

public class ItcastSafetyDoor implements AntiTheft,Fireproof {public void antiTheft() {System.out.println("防盗");}public void fireproof() {System.out.println("防火");}
}

3.5 迪米特法则

迪米特法则又叫最少知识原则。

只和你的直接朋友交谈，不跟“陌生人”说话（Talk only to your immediate friends and not to strangers）。

其含义是：如果两个软件实体无须直接通信，那么就不应当发生直接的相互调用，可以通过第三方转发该调用。其目的是降低类之间的耦合度，提高模块的相对独立性。

迪米特法则中的“朋友”是指：当前对象本身、当前对象的成员对象、当前对象所创建的对象、当前对象的方法参数等，这些对象同当前对象存在关联、聚合或组合关系，可以直接访问这些对象的方法。

下面看一个例子来理解迪米特法则

【例】明星与经纪人的关系实例

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

类图如下：

代码如下：

明星类（Star）

public class Star {private String name;public Star(String name) {this.name=name;}public String getName() {return name;}
}

粉丝类（Fans）

public class Fans {private String name;public Fans(String name) {this.name=name;}public String getName() {return name;}
}

媒体公司类（Company）

public class Company {private String name;public Company(String name) {this.name=name;}public String getName() {return name;}
}

经纪人类（Agent）

public class Agent {private Star star;private Fans fans;private Company company;public void setStar(Star star) {this.star = star;}public void setFans(Fans fans) {this.fans = fans;}public void setCompany(Company company) {this.company = company;}public void meeting() {System.out.println(fans.getName() + "与明星" + star.getName() + "见面了。");}public void business() {System.out.println(company.getName() + "与明星" + star.getName() + "洽淡业务。");}
}

public class Client {public static void main(String[] args) {Agent agent = new Agent();Star star = new Star("张国荣");agent.setStar(star);Fans fans = new Fans("李四");agent.setFans(fans);Company company = new Company("字节跳动");agent.setCompany(company);agent.meeting();agent.business();}
}

3.6 合成复用原则

合成复用原则是指：
尽量先使用组合或者聚合等关联关系来实现，其次才考虑使用继承关系来实现。

继承复用虽然有简单和易实现的优点，但它也存在以下缺点：

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

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

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

下面看一个例子来理解合成复用原则
【例】汽车分类管理程序

汽车按“动力源”划分可分为汽油汽车、电动汽车等；按“颜色”划分可分为白色汽车、黑色汽车和红色汽车等。如果同时考虑这两种分类，其组合就很多。类图如下：

从上面类图我们可以看到使用继承复用产生了很多子类，如果现在又有新的动力源或者新的颜色的话，就需要再定义新的类。我们试着将继承复用改为聚合复用看一下。
在这里插入图片描述

设计模式3-软件设计原则相关推荐

java 设计模式：软件设计原则、面向对象理论、23 种设计模式
文章目录软件设计原则 1.单一职责原则(Single Responsibility Principle) 2.开闭原则(Open Closed Principle) 3.里氏代换原则(Liskov ...
设计模式之软件设计原则篇
3.软件设计原则本文的内容绝大部分借鉴了https://www.jianshu.com/u/cc272db15285的内容,感兴趣的小伙伴可以进入其简书浏览更细的内容,讲的非常好. 在软件开发中,为 ...
译C#使用设计模式和软件设计原则构建应用程序 PartIII
依赖注入这个原则的要点是什么.为什么你不能对类的实例进行再次硬编码?当我们编码,测试的时候,让我们关注一件很重要的事情.希望你知道单元测试并知道它的重要性.也许在你做任何编码之前你都应该首先设计你的 ...
《设计模式详解》软件设计原则
<设计模式详解> 3.软件设计原则 3.1 开闭原则示例 3.2 里式代换原则反例改进反例 3.3 依赖倒转原则反例改进反例 3.4 接口隔离原则反例改进反例 3.5 迪米特 ...
设计模式01 UML图，软件设计原则，创建型模式
概述 "设计模式"最初并不是出现在软件设计中,而是被用于建筑领域的设计中. 1995年,由 Erich Gamma.Richard Helm.Ralph Johnson 和 Joh ...
从零开始学习Java设计模式 | 软件设计原则篇：开闭原则
从本讲开始,咱们就要开始学习第一章中的第三部分内容,即软件设计原则了. 在软件开发中,为了提高软件系统的可维护性和可复用性,增加软件的可扩展性和灵活性,程序员要尽量根据6条原则来开发程序,从而提高软件 ...
设计模式学习笔记1——概述 UML图软件设计原则
目录 1.设计模式概述 1.1.软件设计模式产生背景 1.2.软件设计模式概念 1.3.学习设计模式的必要性 1.4.设计模式分类 1.4.1.创建型模式 1.4.2.结构型模式 1.4.3.行为型模 ...
【设计模式学习01】设计模式概述，UML图，软件设计原则
文章目录 1. 设计模式概述 1.1 软件设计模式的产生背景 1.2 软件设计模式的概念 1.3 学习设计模式的必要性 1.4 设计模式分类 2. UML图 2.1 类图概述 2.2 类图的作用 2. ...
软件设计模式——软件设计原则
摘要设计模式(Design Pattern)是一套被反复使用.多数人知晓的.无数工程师实践的代码设计经验的总结,它是面向对象思想的高度提炼和模板化,使用设计模式是为了让代码具有更高的可重用性,更好的 ...
从零开始学习Java设计模式 | 软件设计原则篇：依赖倒转原则
在本讲,我将为大家介绍软件设计原则里面的第三个原则,即依赖倒转原则. 概述什么是依赖倒转原则呢?我们来看一下下面这段描述: 高层模块不应该依赖低层模块,两者都应该依赖其抽象:抽象不应该依赖细节,细节 ...

设计模式3-软件设计原则