必须知道的软件设计七大原则
1 设计模式
软件设计要遵循设计模式，设计模式就是七大原则的具体实现
提高代码灵活性、重用性、可读性、可扩展性、可靠性 。使程序呈现高内聚低耦合。
懂了设计模式，就懂了面向对象分析和设计（OOA/D）的精要。
2 设计模式七大原则
设计模式的七大原则：
1 单一职责原则 2 接口隔离原则 3 依赖倒转(倒置)原则 4 里氏替换原则 5 开闭原则 ocp 6 迪米特法则 7 合成复用原则
3 单一职责原则
3.1 基本介绍
对类来说，及一个类应该只负责一项原则，如果A负责两个不同的职责：职责1、职责2。当职责1需求变更而改变A时，可能造成职责2执行错误，所以需要将类A的粒度分解为A1,A2
3.2 应用实例
-
方案一,不符合单一原则职责
public class SingResponsibility1 { public static void main(String[] args) { Vehicle vehicle = new Vehicle(); vehicle.run("摩托车"); vehicle.run("汽车"); vehicle.run("飞机"); } } // 交通工具类 // 方式1的分析 // 1. 在方式一 的run方法中，违反了单一职责原则 // 2. 解决的方案非常简单，根据交通工具运行方法不同，分解不同类即可 class Vehicle { public void run(String vehicle){ System.out.println(vehicle + "在公路上运行！"); } } -
方案二，在类上符合单一职责原则
public class SingResponsibility2 { public static void main(String[] args) { RoadVehicle roadVehicle = new RoadVehicle(); roadVehicle.run("汽车"); roadVehicle.run("摩托车"); AirVehicle airVehicle = new AirVehicle(); airVehicle.run("飞机"); WaterVehicle waterVehicle = new WaterVehicle(); waterVehicle.run("轮船"); } } // 方案2的分析 // 1. 遵守单一职责原则 // 2. 但是这样做的改动很大，即将类分解，同时修改客户端 // 3. 改进：直接修改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 + "在海上航行！"); } } -
方案三，在方法上符合单一职责原则
public class SingResponsibility3 { public static void main(String[] args) { Vehicle2 vehicle2 = new Vehicle2(); vehicle2.run("汽车"); vehicle2.runAir("飞机"); vehicle2.runWater("轮船"); } } // 方式3的分析 // 1. 这种修改方法没有对原来的类做大的修改，只是增加方法 // 2. 这里虽然没有在这个类这个级别上遵守单一职责原则，但是在方法级别上仍是遵守单一职责 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 + "在大海上运行！"); } }
3.3 单一职责原则注意事项和细节
- 降低类的复杂度，一个类只负责一项职责。
- 提高类的可读性，可维护性。
- 降低变更引起的风险。
- 通常情况下，我们应该遵守单一职责原则，只有逻辑足够简单，才可以在代码级违反单一职责原则；只有类中方法数量足够少，可以在方法级保持单一职责原则。
4 接口隔离原则（Interface Segregation Principle)
4.1 基本介绍
-
客户端不应该依赖它不需要的接口，即一个类对另一个类的依赖应该建立在最小的接口上。
-
先看一张图
-
类A通过接口Interface1依赖B，类C通过接口Interface1依赖类D，如果接口Interface1对于类A和类C来说不是最小接口那么类B和类D必须去实现他们不需要的方法和类。
-
按隔离原则应当这样处理：
将接口Interface1拆分为独立的几个接口，类A和类C分别与他们需要的接口建立依赖关系。也就是采用接口隔离原则。
4.2 应用实例
- 类A通过接口Interface1依赖类B，类C通过接口Interface1依赖类D
- 将接口拆分，实现接口隔离原则
public class Segregation {
public static void main(String[] args) {
new A().depend1(new B());
new C().depend4(new D());
}
}
interface Interface1 {
void operation1();
void operation2();
void operation3();
void operation4();
void operation5();
}
class A {
public void depend1(Interface1 i) {
i.operation1();
};
public void depend2(Interface1 i) {
i.operation2();
};
public void depend3(Interface1 i) {
i.operation3();
};
}
class B implements Interface1 {
public void operation1() {
System.out.println("B实现了 operation1");
};
public void operation2() {
System.out.println("B实现了 operation2");
};
public void operation3() {
System.out.println("B实现了 operation3");
};
public void operation4() {
System.out.println("B实现了 operation4");
};
public void operation5() {
System.out.println("B实现了 operation5");
};
}
class C {
public void depend1(Interface1 i) {
i.operation1();
};
public void depend4(Interface1 i) {
i.operation4();
};
public void depend5(Interface1 i) {
i.operation5();
};
}
class D implements Interface1 {
public void operation1() {
System.out.println("D实现了 operation1");
};
public void operation2() {
System.out.println("D实现了 operation2");
};
public void operation3() {
System.out.println("D实现了 operation3");
};
public void operation4() {
System.out.println("D实现了 operation4");
};
public void operation5() {
System.out.println("D实现了 operation5");
};
}
实例优化：
public class Segregation {
public static void main(String[] args) {
new A().depend1(new B());
new A().depend2(new B());
new A().depend3(new B());
new C().depend1(new D());
new C().depend4(new D());
new C().depend5(new D());
}
}
interface Interface1 {
void operation1();
}
interface Interface2 {
void operation2();
void operation3();
}
interface Interface3 {
void operation4();
void operation5();
}
class A {
public void depend1(Interface1 i) {
i.operation1();
};
public void depend2(Interface2 i) {
i.operation2();
};
public void depend3(Interface2 i) {
i.operation3();
};
}
class B implements Interface1,Interface2 {
public void operation1() {
System.out.println("B实现了 operation1");
};
public void operation2() {
System.out.println("B实现了 operation2");
};
public void operation3() {
System.out.println("B实现了 operation3");
};
}
class C {
public void depend1(Interface1 i) {
i.operation1();
};
public void depend4(Interface3 i) {
i.operation4();
};
public void depend5(Interface3 i) {
i.operation5();
};
}
class D implements Interface1,Interface3 {
public void operation1() {
System.out.println("D实现了 operation1");
};
public void operation4() {
System.out.println("D实现了 operation4");
};
public void operation5() {
System.out.println("D实现了 operation5");
};
}
5 依赖倒转原则（Dependence Inversion Principle）
5.1 基本介绍
- 高层模块不应该依赖低层模块，二者都应该依赖其抽象
- 抽象不应该依赖细节，细节应该依赖抽象
- 依赖倒转（倒置）的中心思想应该是面向接口编程
- 依赖倒转原则是基于这样的设计理念：相对于细节的多变性，抽象的东西要稳定的多。以抽象为基础搭建的架构比以细节为基础的架构要稳定的多。在Java中，抽象指的是抽象类或接口，细节就是具体的实现类
- 使用接口或抽象类的目的是制定好规范，而不涉及任何具体的操作，把展现细节的任务交给他们的实现类去完成
5.2 应用实例
三种传递方式：
- 接口传递
- 构造方法传递
- setter方法传递
public class DependencyInversion {
public static void main(String[] args) {
People people = new People();
people.receive(new Email());
}
}
class Email {
public String getInfo() {
return "电子邮件信息：hello world!";
}
}
// 1. 简单容易想到
// 2. 接收其他信息 微信短信 需要增加类 ， People 还要增加对应方法
// 3. 解决思路： 引入一个接口IReceive, 表示接收者 这样微信短信实现IReceive接口，这样复合依赖倒转原则
class People {
public void receive (Email email) {
System.out.println(email.getInfo());
}
}
实例优化：
public class DependencyInversion {
public static void main(String[] args) {
People people = new People();
people.receive(new Email());
people.receive(new WeChat());
}
}
interface IReceive {
String getInfo();
}
class Email implements IReceive {
@Override
public String getInfo() {
return "电子邮件信息：hello world!";
}
}
class WeChat implements IReceive {
@Override
public String getInfo() {
return "微信信息：hello world!";
}
}
// 1. 简单容易想到
// 2. 接收其他信息 微信短信 需要增加类 ， People 还要增加对应方法
// 3. 解决思路： 引入一个接口IReceive, 表示接收者 这样微信短信实现IReceive接口，这样复合依赖倒转原则
class People {
public void receive (IReceive receive) {
System.out.println(receive.getInfo());
}
}
public class DependencyPass {
/**
* 可以通过open方法依赖，构造器，setter 等方法传递依赖
* @param args
*/
public static void main(String[] args) {
ITV changHongTV = new ChangHong();
OpenAndClose openAndClose = new OpenAndClose(changHongTV);
openAndClose.open();
}
}
interface IOpenAndClose {
void open();
}
interface ITV {
void play();
}
class ChangHong implements ITV {
@Override
public void play() {
System.out.println("打开长虹电视机");
}
}
class OpenAndClose implements IOpenAndClose {
private ITV tv;
public OpenAndClose(ITV tv) {
this.tv = tv;
}
@Override
public void open() {
tv.play();
}
}
注意事项和细节：
- 低层模块尽量都要有抽象类或接口，或者两者都有，程序稳定性更好
- 变量的声明类型尽量是抽象类或者接口，这样我们的变量引用和实际对象间，就存在一个缓冲层，利用程序扩展和优化
- 继承时遵循里氏替换原则
6 里氏替换原则（Liskov Substitution Principle）
6.1 继承性的思考和说明
- 继承包含这样一层含义：父类中凡是已经实现好的方法，实际上是在设定规范和契约，虽然它不强制要求所有的子类必须遵循这些契约，但是如果子类对这些已经实现的方法任意修改，就会对整个继承体系造成破坏
- 继承在给程序设计带来便利的同时，也带来了弊端，比如使用继承会给程序带来侵入性，程序的可移植性降低，增加了对象间的耦合性，如果一个类被其他的类所继承，则当这个类需要修改时，必须考虑到所有的子类，并且父类修改之后，所有涉及到的子类功能都可能发生故障
- 问题提出：在编程中，如何正确的使用继承？ ==》里氏替换原则
6.2 基本介绍
- 1988年，由麻省理工姓里的女士提出
- 如果每个类型为T1的对象O1，都有类型为T2的对象O2，使得T1定义的所有程序P在所有的对象O1都替换了O2时，程序P的行为没有发生变化，那么类型T2是类型T1的子类型。换句话说，所有引用基类的地方必须能透明的使用其子类的对象
- 在使用继承时，遵循里氏替换原则，在子类中尽量不要重写父类方法
- 继承实际增加了两个类的耦合，适当情况下，可以通过聚合、组合、依赖来解决问题
6.3 应用实例
public class Liskov {
public static void main(String[] args) {
A a = new A();
System.out.println("11-3= " + a.fun1(11, 3));
System.out.println("1-8= " + a.fun1(1, 8));
B b = new B();
System.out.println("11-3= " + b.fun1(11, 3));
System.out.println("1-8= " + b.fun1(1, 8));
System.out.println("1-8+8= " + b.fun2(1, 8));
}
}
class A {
public int fun1(int num1,int num2) {
return num1 - num2;
}
}
// B类不小心重写了A类的方法
class B extends A {
public int fun1(int num1,int num2) {
return num1 + num2;
}
public int fun2(int num1,int num2) {
return fun1(num1,num2) + num2;
}
}
实例优化:
public class Liskov {
public static void main(String[] args) {
A a = new A();
System.out.println("11-3= " + a.fun1(11, 3));
System.out.println("1-8= " + a.fun1(1, 8));
B b = new B();
// B类不再继承A类
System.out.println("1-8+8= " + b.fun2(1, 8));
}
}
class Base {
}
class A extends Base {
public int fun1(int num1,int num2) {
return num1 - num2;
}
}
// B类不小心重写了A类的方法
class B extends Base {
private A a = new A(); // 组合
public int fun1(int num1,int num2) {
return num1 + num2;
}
public int fun2(int num1,int num2) {
return a.fun1(num1,num2) + num2;
}
}
6.4 解决办法
- 我们发现原来运行正常的相减功能发生了错误。在实际编程中，我们常常会通过重写父类的方法完成新的功能，这样写起来虽然简单，但是整个继承体系的复用性比较差，特别是运行多态比较平凡的时候
- 通常做法：原来的父类和子类都继承一个更通俗的基类，原有的继承关系去掉，采用依赖，聚合，组合等关系代替
7 开闭原则（Open Closed Principle）
7.1 基本介绍
- 开闭原则是编程最基础、最重要的原则
- 一个软件实体如类，模块和函数应该对扩展开放（对提供方），对修改关闭（对使用方）。用抽象构建框架，用实现展示细节
- 当软件需求变化时，尽量通过扩展软件实体的行为来实现变化，而不是通过修改已有的代码来实现变化
- 编程中遵循其它原则，以及使用设计模式的目的就是遵循开闭原则
7.2 应用实例
public class Ocp {
public static void main(String[] args) {
GraphicEditor graphicEditor = new GraphicEditor();
graphicEditor.drawRectangle(new Rectangle());
graphicEditor.drawCircle(new Circle());
// 如果新增三角形
}
}
// 用于绘画的类
class GraphicEditor {
public void drawShape(Shape s) {
if (s.m_type == 1) {
drawRectangle(s);
} else if (s.m_type == 2) {
drawCircle(s);
}
}
public void drawRectangle(Shape s) {
System.out.println("绘制矩形");
}
public void drawCircle(Shape s) {
System.out.println("绘制圆形");
}
}
class Shape {
int m_type;
}
class Rectangle extends Shape {
Rectangle() {
super.m_type = 1;
}
}
class Circle extends Shape {
Circle() {
super.m_type = 2;
}
}
实例优化：
public class Ocp {
public static void main(String[] args) {
GraphicEditor graphicEditor = new GraphicEditor();
graphicEditor.drawShape(new Rectangle());
graphicEditor.drawShape(new Circle());
// 如果新增三角形
graphicEditor.drawShape(new Triangle());
}
}
// 用于绘画的类
class GraphicEditor {
public void drawShape(Shape s) {
s.draw();
}
}
abstract class Shape {
int m_type;
public abstract void draw();
}
class Rectangle extends Shape {
Rectangle() {
super.m_type = 1;
}
@Override
public void draw() {
System.out.println("绘制矩形");
}
}
class Circle extends Shape {
Circle() {
super.m_type = 2;
}
@Override
public void draw() {
System.out.println("绘制圆形");
}
}
class Triangle extends Shape {
Triangle() {
super.m_type = 3;
}
@Override
public void draw() {
System.out.println("绘制三角形");
}
}
8 迪米特法则（Demeter Principle）
8.1 基本介绍
- 一个对象应该对其他对象保持最少的了解
- 类与类之间关系越密切，耦合度越大
- 迪米特法则又叫最少知道原则，即一个类对自己依赖的类知道的越少越好，也就是说，对于被依赖的类不管多么复杂，都尽量将逻辑封装在类的内部，对外除了提供public方法，不对外提供任何信息
- 迪米特法则还有个更简单的定义：只与朋友通信
- 直接的朋友：每个对象都会与其它对象由耦合关系，只要两个对象之间有耦合关系，我们就说这两个对象之间是朋友关系。耦合的方式有很多，依赖，关联，组合，聚合等等。其中我们称出现成员变量，方法参数，方法返回值中的类为直接的朋友，而出现在局部变量中的类不是直接的朋友。也就是说，陌生的类最好不要以局部变量的形式出现在类的内部。
8.2 应用实例
public class Demeter {
public static void main(String[] args) {
SchoolManage schoolManage = new SchoolManage();
schoolManage.printAllEmployee(new CollegeManage());
}
}
class Employee {
private String id;
public void setId(String id) {
this.id = id;
}
public String getId() {
return id;
}
}
class CollegeEmployee {
private String id;
public void setId(String id) {
this.id = id;
}
public String getId() {
return id;
}
}
class CollegeManage {
public List<CollegeEmployee> getAllEmployee() {
List<CollegeEmployee> list = new ArrayList<>();
for (int i = 0; i < 10; i++) {
CollegeEmployee emp = new CollegeEmployee();
emp.setId("学院员工ID= " + i);
list.add(emp);
}
return list;
}
}
// 直接朋友类 Employee CollegeMange 陌生：CollegeEmployee
class SchoolManage {
public List<Employee> getAllEmployee() {
List<Employee> list = new ArrayList<>();
for (int i = 0; i < 5; i++) {
Employee emp = new Employee();
emp.setId("总部员工ID= " + i);
list.add(emp);
}
return list;
}
public void printAllEmployee(CollegeManage cm) {
List<CollegeEmployee> collegeEmployees = cm.getAllEmployee();
System.out.println("----------------分公司员工------------------");
for (CollegeEmployee emp:
collegeEmployees) {
System.out.println(emp.getId());
}
List<Employee> employees = getAllEmployee();
System.out.println("----------------总公司员工------------------");
for (Employee emp:
employees) {
System.out.println(emp.getId());
}
}
}
实例优化：
public class Demeter {
public static void main(String[] args) {
SchoolManage schoolManage = new SchoolManage();
schoolManage.printAllEmployee(new CollegeManage());
}
}
class Employee {
private String id;
public void setId(String id) {
this.id = id;
}
public String getId() {
return id;
}
}
class CollegeEmployee {
private String id;
public void setId(String id) {
this.id = id;
}
public String getId() {
return id;
}
}
class CollegeManage {
public List<CollegeEmployee> getAllEmployee() {
List<CollegeEmployee> list = new ArrayList<>();
for (int i = 0; i < 10; i++) {
CollegeEmployee emp = new CollegeEmployee();
emp.setId("学院员工ID= " + i);
list.add(emp);
}
return list;
}
public void printAllEmployee() {
List<CollegeEmployee> collegeEmployees = getAllEmployee();
System.out.println("----------------分公司员工------------------");
for (CollegeEmployee emp:
collegeEmployees) {
System.out.println(emp.getId());
}
}
}
class SchoolManage {
public List<Employee> getAllEmployee() {
List<Employee> list = new ArrayList<>();
for (int i = 0; i < 5; i++) {
Employee emp = new Employee();
emp.setId("总部员工ID= " + i);
list.add(emp);
}
return list;
}
public void printAllEmployee(CollegeManage cm) {
cm.printAllEmployee();
List<Employee> employees = getAllEmployee();
System.out.println("----------------总公司员工------------------");
for (Employee emp:
employees) {
System.out.println(emp.getId());
}
}
}
注意事项和细节：
- 迪米特法则核心是降低耦合
- 每个类都减少了不必要的依赖，因此迪米特法则只是要求降低耦合度，并不是完全没有耦合
9 合成复用原则（Composite Reuse Principle）
9.1 基本介绍
尽量使用合成或聚合的方式，而不是继承
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
