设计模式的七大原则
2021/12/8 6:21:10
本文主要是介绍设计模式的七大原则,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!
设计模式的七大原则
一.设计模式的目的
编写软件过程,程序员面临着来自耦合性,内聚性以及可维护性,可扩展性,重用性,灵活性 等多方面的挑战,设计模式是为了让程序(软件),具有更好
-
代码重用性(即:相同功能的代码,不用多次编写)
-
可读性(即:编程规范性,便于其他程序员的阅读和理解)
-
可扩展性(即:当需要增加新的功能时,非常的方便,称为可维护)
-
可靠性(即:当我们增加新的功能后,对原来的功能没有影响)
-
是程序呈现高内聚,低耦合的特性
二.设计模式七大原则
设计模式原则,其实就是程序员在编程时,应当遵守的原则,也是各种设计模式的基础
①单一职责原则
②接口隔离原则
③依赖倒转(倒置)原则
④里氏替换原则
⑤开闭原则(OCP)
⑥迪米特法则
⑦合成复用原则
1.单一职责原则
1.1基本介绍
对类来说,即一个类只负责一项职责。如类A负责两个不同职责:职责1,职责2。当职责1需求变更而改变A时,可能造成职责2执行错误,所以需要将类A的粒度分解为A1,A2
1.2应用案例
案例1(违反了原则)
public class SingleResponsibility1 { public static void main(String[] args) { Vehicle vehicle = new Vehicle(); vehicle.run("摩托车"); vehicle.run("汽车"); vehicle.run("飞机"); } } //解决方式:根据交通工具运行方法不同,分解成不同类即可 /** * 交通工具类 * 方案1 * 1.在方式1的run方法中,违反了单一职责原则 * 解决方式:根据交通工具运行方法不同,分解成不同类即可 */ class Vehicle { public void run(String vehicle) { System.out.println(vehicle + " 在公路上运行...."); } }
案例2(遵守了,但成本太高)
/** * 单一职责原则 * * @author wwh * */ public class SingleResponsibility2 { /** * @param args */ 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("飞机"); } } /** * 方案2的分析 * 1.遵守单一职责原则 * 2.但是这样做的功能改动很大,将类分解,同时修改客户端 * 改进:直接修改Vehicle类,改动的代码会比较少=>3 * */ 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 + " 水中运行..."); } }
案例3 (方法级别的单一职责原则)
/** * 单一职责原则 * * @author wwh * */ public class SingleResponsibility3 { /** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub 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 + " 在水中运行..."); } }
避免出现,这样耦合性很高
If(条件1){
}else if(条件②{
}else if(条件3){
}
1.3单一职责原则注意事项和细节
①降低类的复杂度,一个类只负责一项职责
② 提高类的可读性,可维护性
③降低变更引起的风险
④ 通常情况下,我们应当遵守单一职责原则,只用逻辑足够简单,才可以在代码级别违反单一职责原则,只有类中方法数量足够少,可以在方法级别保持单一职责原则
2.接口隔离原则(Interface Segregation Principle)
2.1基本介绍
①客户端不应该依赖它不需要的接口,即一个类对另一个类的依赖应该建立在最小的接口上
② 看一张图
解析类图:
类A通过Interface1依赖类B,类C通过Interface1依赖类D,如果接口Interface1对于类A和类C来说不是最小接口,那么类B和类D必须去实现他们不需要的方法,造成了资源浪费
按隔离原则应当这样处理:
将接口Interface1拆分为**独立的几个接口(这里我们拆分成3个接口),**类A和类C分别与他们需要的接口建立依赖关系.也就是采用接口隔离原则
2.2应用实例
示例一(违反了原则)
类A通过Interface1依赖类B,类C通过Interface1依赖类D
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 {// A 类通过接口Interface1 依赖(使用)B类,但是只会用到1,2,3方法 public void depend1(Interface1 i){ i.operation1(); } public void depend2(Interface1 i){ i.operation2(); } public void depend3(Interface1 i){ i.operation3(); } } class C {// C 类通过接口Interface1 依赖(使用)D类,但是只会用到1,4,5方法 public void depend1(Interface1 i){ i.operation1(); } public void depend4(Interface1 i){ i.operation4(); } public void depend5(Interface1 i){ i.operation5(); } }
示例二
将接口Interface1拆分为**独立的几个接口(这里我们拆分成3个接口),**类A和类C分别与他们需要的接口建立依赖关系.也就是采用接口隔离原则
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()); System.out.println("-------------------------"); C c = new C(); c.depend1(new D());// C类通过接口去依赖D类 c.depend4(new D()); c.depend5(new D()); } } //接口1 interface Interface1{ void operation1(); } //接口2 interface Interface2{ void operation2(); void operation3(); } //接口3 interface Interface3{ void operation4(); void operation5(); } //B实现Interface1和Interface2 class B implements Interface1,Interface2{ @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"); } } //D实现Interface1和Interface3 class D implements Interface1,Interface3{ @Override public void operation1() { System.out.println("D 实现了 operation1"); } @Override public void operation4() { System.out.println("D 实现了 operation4"); } @Override public void operation5() { System.out.println("D 实现了 operation5"); } } class A {// A 类通过接口Interface1,Interface2 依赖(使用)B类,但是只会用到1,2,3方法 public void depend1(Interface1 i){ i.operation1(); } public void depend2(Interface2 i){ i.operation2(); } public void depend3(Interface2 i){ i.operation3(); } } class C {// C 类通过接口Interface1,Interface3 依赖(使用)D类,但是只会用到1,4,5方法 public void depend1(Interface1 i){ i.operation1(); } public void depend4(Interface3 i){ i.operation4(); } public void depend5(Interface3 i){ i.operation5(); } }
3. 依赖倒转原则(Dependence Inversion Principle)
3.1基本介绍
①高层模块不应该依赖底层模块,二者都应该依赖其抽象
② 抽象不应该依赖细节,细节应该依赖抽象
③依赖倒转(倒置)的中心思想是面向接口编程
④ 依赖倒转原则是基于这样的设计理念:相对于细节的多变性,抽象的东西要稳定的多。在Java中,抽象指的是接口或抽象类,细节就是具体的实现类
⑤ 使用接口或抽象类的目的是制定好规范,而不是涉及任何具体操作,把展现细节的任务交给他们的实现类去完成
3.2应用案例
案例一
public class DependencyInversion { public static void main(String[] args) { Person person = new Person(); person.receive(new Email()); } } class Email{ public String getInfo(){ return "电子邮件信息: Hello,world"; } } /** * 完成Person接收消息的功能 * 示例一分析 * 1.简单,比较容易想到 * 2.如果我们获取信息对象是 微信,短信等等,新增类,同时Person也要增加相应的接收方法 * 解决思路: 引入一个抽象的接口IReceiver,表示接收者,这样Person类与接口IReceiver发生依赖 * 因为Email,WeChat 等等属于接收的范围,他们各自实现IReceiver接口,这样我们就符合依赖倒转原则 */ class Person{ public void receive(Email email){ System.out.println(email.getInfo()); } }
案例二
public class DependencyInversion { public static void main(String[] args) { Person person = new Person(); person.receive(new Email()); person.receive(new WeChat()); } } //定义接口 interface IReceiver{ public String getInfo(); } //邮箱 class Email implements IReceiver{ public String getInfo(){ return "电子邮件信息: Hello,world"; } } //微信 class WeChat implements IReceiver{ public String getInfo(){ return "微信信息: Hello,WeChat"; } } class Person{ //是对接口进行了依赖 public void receive(IReceiver iReceiver){ System.out.println(iReceiver.getInfo()); } }
3.3依赖关系传递的三种方式和应用案例
①接口传递
②构造方法传递
③Setter方法传递
/** * 依赖关系传递的三种方式 * */ public class DependencyPass { public static void main(String[] args) { //使用方式一:接口传递 /*ChangHong changHong = new ChangHong(); OpenAndClose openAndClose = new OpenAndClose(); openAndClose.open(changHong);*/ //使用方式二:构造方法传递 /*ChangHong changHong = new ChangHong(); OpenAndClose openAndClose = new OpenAndClose(changHong); openAndClose.open();*/ //使用方式三:setter方法传递 ChangHong changHong = new ChangHong(); OpenAndClose openAndClose = new OpenAndClose(); openAndClose.setTV(changHong); openAndClose.open(); } } /** * 方式一:通过接口传递实现依赖 * */ //开关接口 /*interface IOpenAndClose{ public void open(ITV tv);//抽象方法,接收接口 } interface ITV{//ITV接口 public void play();//打开方式 } //实现接口 class OpenAndClose implements IOpenAndClose{ @Override public void open(ITV tv) { tv.play(); } }*/ class ChangHong implements ITV{ @Override public void play() { // TODO Auto-generated method stub System.out.println("长虹电视机,打开 "); } } /** * 方式二:通过构造方法实现依赖传递 * */ //开关接口 /*interface IOpenAndClose{ public void open();//抽象方法,接收接口 } interface ITV{//ITV接口 public void play();//打开方式 } //实现接口 class OpenAndClose implements IOpenAndClose{ private ITV tv;//成员 public OpenAndClose(ITV tv) {//构造器 this.tv = tv; } @Override public void open() { tv.play(); } }*/ /** * 方式三:通过setter方法实现依赖传递 * */ //开关接口 interface IOpenAndClose{ public void open();//抽象方法,接收接口 public void setTV(ITV tv); } interface ITV{//ITV接口 public void play();//打开方式 } //实现接口 class OpenAndClose implements IOpenAndClose{ private ITV tv;//成员 @Override public void setTV(ITV tv) { this.tv = tv; } @Override public void open() { tv.play(); } }
3.4依赖倒转原则的注意事项和细节
①低层模块尽量都要有抽象类或接口,或者两者都有,程序稳定性会更好
② 变量的声明类型尽量是抽象类或接口,这样我们的变量引用和实际对象间就存在一个缓冲层,利用程序扩展和优化
③继承是遵守里氏替换原则
4.里氏替换原则
4.1 OO中生物继承性的思考和说明
①继承包含这样一层含义:父类中凡是已经实现好的方法,实际上是在设定规范和契约,虽然它不强制要求说有的子类必须遵循这些契约,但是如果子类对这些已经实现的方法任意修改,就会对整个继承体系造成破坏。
② 继承在给程序设计带来便利的同时,也带来了弊端。比如使用继承会给程序带来侵入性,程序的可移植性降低,增加对象间的耦合性,如果一个类被其他的类所继承,则当这个类需要修改时,必须考虑到所有的子类,并且父类修改后,所有涉及到的子类的功能都有可能产生故障
问题提出:在编程中,如果正确的使用继承?====>里氏替换原则
4.2基本介绍
①里氏替换原则(Liskov Substitution Principle)在1988年,由麻省理工学院的以姓李的女士提出的
② 所有引用基类的地方必须能透明地使用其子类的对象
③在使用继承时,遵循里氏替换原则,在子类中尽量不要重写父类的方法
④ 里氏替换原则告诉我们,继承实际上让两个类耦合性增强了,在适当的情况下,可以通过聚合,组合,依赖 来解决问题
4.3应用案例
案例一(违反了)
public class Liskov1 { public static void main(String[] args) { // TODO Auto-generated method stub A a = new A(); System.out.println("11-3=" + a.func1(11, 3)); System.out.println("1-8=" + a.func1(1, 8)); System.out.println("---------------------------------"); B b = new B(); System.out.println("11-3=" + b.func1(11, 3));//本意时求出11-3 System.out.println("1-8=" + b.func1(1, 8));//1-8 System.out.println("11+3+9=" + b.func2(11, 3)); } } //A类 class A { //返回两个数的差 public int func1(int num1, int num2){ return num1 - num2; } } //B类继承了A // 增加了一个新功能:完成两个数相加,然后和9求和 class B extends A { //这里,重写了A类的方法,可能是无意识 public int func1(int a, int b){ return a + b; } public int func2(int a, int b){ return func1(a, b) + 9; } }
案例二(改进)
public class Liskov1 { public static void main(String[] args) { // TODO Auto-generated method stub A a = new A(); System.out.println("11-3=" + a.func1(11, 3)); System.out.println("1-8=" + a.func1(1, 8)); System.out.println("---------------------------------"); B b = new B(); //因为B类不再继承A类,因此调用者,不会再func1是求减法 //调用完成的功能就会很明确 System.out.println("11+3=" + b.func1(11, 3));//本意时求出11+3 System.out.println("1+8=" + b.func1(1, 8));//1+8 System.out.println("11+3+9=" + b.func2(11, 3)); //使用组合仍然可以使用到A类相关方法 System.out.println("11-3=" + b.func3(11, 3));//本意时求出11-3 } } //创建一个更加基础的基类 class Base { //把更加基础的方法和成员写到Base类 } //A类 class A extends Base{ //返回两个数的差 public int func1(int num1, int num2){ return num1 - num2; } } //B类继承了A // 增加了一个新功能:完成两个数相加,然后和9求和 class B extends Base { //如果B需要使用A类的方法,使用组合关系 private A a = new A(); //这里,重写了A类的方法,可能是无意识 public int func1(int a, int b){ return a + b; } public int func2(int a, int b){ return func1(a, b) + 9; } //使用A类中的方法 public int func3(int a, int b){ return this.a.func1(a, b); } }
5.开闭原则(OCP)
5.1基本介绍
①开闭原则(Open Closed Principle)是编程中最基础、最重要的设计原则
② 一个软件实体如类,模块和函数应该对扩展开放(对提供方),对修改关闭(对使用方)。用抽象构建框架,用实现扩展细节
③当软件需要变化时,尽量通过扩展软件实体的行为,来实现变化,而不是通过修改已有的代码来实现变化。
④ 编程中遵循其他原则,以及使用设计模式的目的就是遵循开闭原则
5.2应用案例
案例一(违反了)
分析方式一:
①优点是比较好理解,简单易操作
② 缺点是违反了设计模式的OCP原则,即对扩展开放(提供方),对修改关闭(使用方)。即当我们给类增加新功能的时候,尽量不修改代码,或者尽可能少修改代码
③比如我们这时要新增加一个图形类 三角形 , 我们需要做如下修改,修改的地方较多
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 { //接收Shape对象,然后根据type,来绘制不同的图形 public void drawShape(Shape s){ if(s.m_type == 1){ drawRectangle(s); }else if(s.m_type == 2){ drawCircle(s); }else if(s.m_type == 3){ drawTriangle(s); } } //绘制矩形 public void drawRectangle(Shape s) { System.out.println(" 绘制矩形 "); } //绘制圆形 public void drawCircle(Shape s) { System.out.println(" 绘制圆形 "); } //绘制三角形 public void drawTriangle(Shape s) { System.out.println(" 绘制三角形 "); } } //Shape基类 class Shape{ int m_type; } class Rectangle extends Shape { Rectangle(){ super.m_type = 1; } } class Circle extends Shape { Circle(){ super.m_type = 2; } } //新增画三角形 class Triangle extends Shape { Triangle(){ super.m_type = 3; } }
案例二(改进)
方式二:把创建Shape类做成抽象类,并提供一个抽象的draw方法,让子类去实现即可,这样我们有新的图形种类时,是需要让新的图形类继承Shape,并实现draw方法即可,使用方的代码就不需要修改 满足了开闭原则
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()); graphicEditor.drawShape(new OtherGraphic()); } } //这是一个用于绘图的类[使用方] class GraphicEditor { //接收Shape对象,调用draw方法 public void drawShape(Shape s){ s.draw(); } } //抽象Shape基类 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(" 绘制三角形 "); } } //新增其他图形 class OtherGraphic extends Shape{ OtherGraphic(){ super.m_type = 4; } @Override public void draw() { System.out.println(" 绘制其他图形 "); } }
6.迪米特法则(Demeter Principle)
6.1基本介绍
①一个对象应该对其他对象保持最少的了解
② 类与类关系越密切,耦合度越大
③迪米特法则(Demeter Principle)又叫最少知道法则,即一个类**对自己依赖的类知道越少越好。**也就是说,对于依赖的类不管多么负责,都尽量将逻辑封装在类的内部。对于除了提供的public方法,不对外泄露任何信息
④ 迪米特法则还有个更简单的定义:只与直接朋友通信
5) 直接的朋友:每个对象都会与其他对象有耦合关系,只要两个对象之间有耦合关系,我们就说这个两个对象之间是朋友关系。耦合的方式很多,依赖,关联,组合,聚合等。其中,我们称出现成员变量,方法参数,方法返回值中的类为直接的朋友,而出现在局部变量中的类不是直接朋友。也就是说,陌生的类最好不要以局部变量的形式出现在类的内部
6.2应用案例
案例一(违反了)
分析问题
1.这里的CollegeEmployee 不是 SchoolManager的直接朋友
2.CollegeEmployee是以局部变量方式出现在 SchoolManager
3.违反了 迪米特法则
//客户端 public class Demeter1 { public static void main(String[] args) { // 创建了一个SchoolManager 对象 SchoolManager schoolManager = new SchoolManager(); //输出学院的员工id 和 学校总部的员工信息 schoolManager.printAllEmployee(new CollegeManager()); } } //学校总部员工 class Employee { private String id; public String getId() { return id; } public void setId(String id) { this.id = id; } } //学院的员工类 class CollegeEmployee { private String id; public String getId() { return id; } public void setId(String id) { this.id = id; } } //管理学院员工的管理类 class CollegeManager { //返回学校的所有员工 public List<CollegeEmployee> getAllEmployee(){ List<CollegeEmployee> list = new ArrayList<CollegeEmployee>(); for(int i = 0; i < 10;i++){//模拟增加了10个员工到list集合 CollegeEmployee employee = new CollegeEmployee(); employee.setId("学院员工id= "+i); list.add(employee); } return list; } } //管理学校员工的管理类 /** * 分析SchoolManager 类的直接朋友类有哪些 Employee,CollegeManager * CollegeEmployee 不是直接朋友 而是一个陌生类,这样违背了 迪米特法则 * */ class SchoolManager { //返回学校总部的员工 public List<Employee> getAllEmployee(){ List<Employee> list = new ArrayList<Employee>(); for(int i = 0; i < 5;i++){//模拟增加了5个员工到list集合 Employee employee = new Employee(); employee.setId("学校员工id= "+i); list.add(employee); } return list; } //该方法完成输出学校总部和学院员工信息(id) public void printAllEmployee(CollegeManager sub){ /** * 分析问题 * 1.这里的CollegeEmployee 不是 SchoolManager的直接朋友 * 2.CollegeEmployee是以局部变量方式出现在 SchoolManager * 3.违反了 迪米特法则 */ //获取到学院员工 List<CollegeEmployee> list1 = sub.getAllEmployee(); System.out.println("---------------学院员工---------------"); list1.forEach(e->{ System.out.println(e.getId()); }); //获取到学校总部员工 List<Employee> list2 = this.getAllEmployee(); System.out.println("---------------学校总部员工---------------"); for(Employee e : list2){ System.out.println(e.getId()); } } }
案例二(改进)
改进问题
1.将输出学院的员工方法,封装到CollegeManager中
//客户端 public class Demeter1 { public static void main(String[] args) { System.out.println("~~~使用迪米特法则改进~~~"); // 创建了一个SchoolManager 对象 SchoolManager schoolManager = new SchoolManager(); //输出学院的员工id 和 学校总部的员工信息 schoolManager.printAllEmployee(new CollegeManager()); } } //学校总部员工 class Employee { private String id; public String getId() { return id; } public void setId(String id) { this.id = id; } } //学院的员工类 class CollegeEmployee { private String id; public String getId() { return id; } public void setId(String id) { this.id = id; } } //管理学院员工的管理类 class CollegeManager { //返回学校的所有员工 public List<CollegeEmployee> getAllEmployee(){ List<CollegeEmployee> list = new ArrayList<CollegeEmployee>(); for(int i = 0; i < 10;i++){//模拟增加了10个员工到list集合 CollegeEmployee employee = new CollegeEmployee(); employee.setId("学院员工id= "+i); list.add(employee); } return list; } public void printCollegeEmployee(){ //获取到学院员工 List<CollegeEmployee> list1 = this.getAllEmployee(); System.out.println("---------------学院员工---------------"); list1.forEach(e->{ System.out.println(e.getId()); }); } } //管理学校员工的管理类 /** * 分析SchoolManager 类的直接朋友类有哪些 Employee,CollegeManager * CollegeEmployee 不是直接朋友 而是一个陌生类,这样违背了 迪米特法则 * */ class SchoolManager { //返回学校总部的员工 public List<Employee> getAllEmployee(){ List<Employee> list = new ArrayList<Employee>(); for(int i = 0; i < 5;i++){//模拟增加了5个员工到list集合 Employee employee = new Employee(); employee.setId("学校员工id= "+i); list.add(employee); } return list; } //该方法完成输出学校总部和学院员工信息(id) public void printAllEmployee(CollegeManager sub){ /** * 改进问题 * 1.将输出学院的员工方法,封装到CollegeManager中 */ sub.printCollegeEmployee(); //获取到学校总部员工 List<Employee> list2 = this.getAllEmployee(); System.out.println("---------------学校总部员工---------------"); for(Employee e : list2){ System.out.println(e.getId()); } } }
6.3迪米特法则注意事项和细节
①迪米特法则的核心是降低类之间的耦合
② 由于每个类都减少了不必要的依赖,因此迪米特法则只是要求降低类间(对象间)耦合关系,并不是要求完全没有依赖关系
7.合成复用原则(Composite Reuse Principle)
7.1基本介绍
原则是尽量使用合成/聚合的方式,而不是使用继承
8.设计原则核心思想
①找出应用中可能需要变化之处,把它们独立出来,不要和那些不需要变化的代码混合在一起
②针对接口编程,而不是针对实现编程
③为交互对象之间的松耦合设计而努力
学习于尚硅谷韩老师https://www.bilibili.com/video/BV1G4411c7N4?from=search&seid=5338559785918172694&spm_id_from=333.337.0.0
这篇关于设计模式的七大原则的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!
- 2024-06-26结对编程到底难不难?答案在这里
- 2024-06-19《2023版Java工程师》课程升级公告
- 2024-06-15matplotlib作图不显示3D图,怎么办?
- 2024-06-1503-Loki 日志监控
- 2024-06-1504-让LLM理解知识 -Prompt
- 2024-06-05做软件测试需要懂代码吗?
- 2024-06-0514-ShardingSphere的分布式主键实现
- 2024-06-03为什么以及如何要进行架构设计权衡?
- 2024-05-31全网首发第二弹!软考2024年5月《软件设计师》真题+解析+答案!(11-20题)
- 2024-05-31全网首发!软考2024年5月《软件设计师》真题+解析+答案!(21-30题)