设计模式七大原则（设计模式入门必学！也就是设计模式为什么这样设计的依据）

最新推荐文章于 2024-09-13 21:40:38 发布

我觉得海星_98

最新推荐文章于 2024-09-13 21:40:38 发布

阅读量101

点赞数 1

本文链接：https://blog.csdn.net/qq_42709715/article/details/115269857

版权

设计模式专栏收录该内容

23 篇文章 0 订阅

订阅专栏

设计模式七大原则

文章目录

设计模式七大原则

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

单一职责原则

对类来说的，即一个类应该只负责一项职责。

/**
 * @author 漆剑
 * @date 2021-03-27
 * @description
 */
public class SingleResponsibility1 {
    public static void main(String[] args) {
        Vehicle vehicle = new Vehicle();
        vehicle.run("摩托🏍️");
        vehicle.run("汽车🚗");
        vehicle.run("飞机✈️");

    }
}

class Vehicle{
    public void run(String vehicle){
        System.out.println(vehicle + "在公路上运行！");
    }
}

从上面代码可以看出，这是一个错误示范。
如果说摩托车/汽车可以在公路上运行，但是飞机不能！
利用单一职责原则改进代码如下：

/**
 * @author 漆剑
 * @date 2021-03-27
 * @description
 */
public class SingleResponsibility3 {
    public static void main(String[] args) {
        Vehicle2 vehicle2 = new Vehicle2();
        vehicle2.run("汽车");
        vehicle2.runAir("飞机");
        vehicle2.runWater("c船");

    }
}
class Vehicle2{
    public void run(String vehicle){
        System.out.println(vehicle + "在公路上运行！");
    }
    public void runAir(String vehicle){
        System.out.println(vehicle + "在sky上运行！");
    }
    public void runWater(String vehicle){
        System.out.println(vehicle + "在shui上运行！");
    }
}

这里你也可以把Vehicle2拆分成三个类去实现，但如果结构过于简单，则无需拆分！

接口隔离原则

客户端不应该依赖它不需要的接口，即一个类对另一个类的依赖应该建立在最小的接口上。

/**
 * @author 漆剑
 * @date 2021-03-27
 * @description
 */
/**
 * @author 漆剑
 * @date 2021-03-27
 * @description
 */
public class Segregation1 {
    public static void main(String[] args) {
        
    }
}
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 depend1(Interface1 i){
        i.operation1();
    }
    public void depend2(Interface1 i){
        i.operation2();
    }
    public void depend3(Interface1 i){
        i.operation3();
    }
}

class C{
    public void depend1(Interface1 i){
        i.operation1();
    }
    public void depend4(Interface1 i){
        i.operation4();
    }
    public void depend5(Interface1 i){
        i.operation5();
    }
}

从上面代码可以看出，这是一个错误示范。
这里可以看出：类 A 通过接口 Interface1 依赖类 B，类 C 通过接口 Interface1 依赖类 D，
如果接口 Interface1 对于类 A 和类 C 来说不是最小接口，那么类 B 和类 D 必须去实现他们
不需要的方法
利用接口隔离原则改进代码如下：

/**
 * @author 漆剑
 * @date 2021-03-27
 * @description
 */
public class Segregation1 {
    public static void main(String[] args) {
        A a = new A();
        a.depend1(new B());
        a.depend2(new B());
        a.depend3(new B());
        C c = new C();
        c.depend1(new D());
        c.depend4(new D());
        c.depend5(new D());

    }
}

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

class B implements Interface1, Interface23{

    @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");
    }
}

class D implements Interface1, Interface45{

    @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{
    public void depend1(Interface1 i){
        i.operation1();
    }
    public void depend2(Interface23 i){
        i.operation2();
    }
    public void depend3(Interface23 i){
        i.operation3();
    }
}

class C{
    public void depend1(Interface1 i){
        i.operation1();
    }
    public void depend4(Interface45 i){
        i.operation4();
    }
    public void depend5(Interface45 i){
        i.operation5();
    }
}

依赖倒转原则

高层模块不应该依赖低层模块，二者都应该依赖其抽象。（抽象便于维护和拓展）

/**
 * @author 漆剑
 * @date 2021-03-27
 * @description
 */
public class DependecyInversion {
    public static void main(String[] args) {
        Person person = new Person();
        person.receive(new Email());
    }
}
 class Email {
    public String getInfo(){
        return "电子邮件信息：hello world";
    }

}
class Person {
    public void receive(Email email){
        System.out.println(email.getInfo());
    }
}

从上面代码可以看出，这是一个错误示范。
人员接收邮件可以看做接收某种消息，也就是说邮件应该通过消息抽象来维护
利用依赖倒转原则改进代码如下：

/**
 * @author 漆剑
 * @date 2021-03-27
 * @description
 */
public class DependecyInversion {
    public static void main(String[] args) {
        Person person = new Person();
        person.receive(new Email());

        person.receive(new weeiin());
    }
}
interface IReceiver{
    public String getInfo();
}

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

}
class weeiin implements IReceiver{

    @Override
    public String getInfo() {
            return "weeiixxin邮件信息：hello world";
    }
}
class Person {
    public void receive(IReceiver iReceiver){
        System.out.println(iReceiver.getInfo());
    }
}

里氏替换原则

所有引用基类的地方必须能透明地使用其子类的对象。（在子类中尽量不要重写父类的方法）

/**
 * @author 漆剑
 * @date 2021-03-27
 * @description
 */
public class Liskov {

	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;
	}
}

从上面代码可以看出，这是一个错误示范。
父类的func1数值相减功能出现了异常，被子类进行了重写，而我们要在子类中不对父类功能进行
修改
利用里氏替换原则改进代码如下：

/**
 * @author 漆剑
 * @date 2021-03-27
 * @description
 */
public class Liskov {

	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);
	}
}

开闭原则（最基础、最重要的设计原则）

一个软件实体如类，模块和函数应该对扩展开放(对提供方)，对修改关闭(对使用方)。

/**
 * @author 漆剑
 * @date 2021-03-27
 * @description
 */
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 r) {
		System.out.println(" 绘制矩形 ");
	}

	//绘制圆形
	public void drawCircle(Shape r) {
		System.out.println(" 绘制圆形 ");
	}

	//绘制三角形
	public void drawTriangle(Shape r) {
		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，不仅要对实例修改，还要修改GraphicEditor内部的逻辑判断
利用开闭原则改进代码如下：

/**
 * @author 漆剑
 * @date 2021-03-27
 * @description
 */
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 {

	public abstract void draw();//抽象方法
}

class Rectangle extends Shape {

	@Override
	public void draw() {
		// TODO Auto-generated method stub
		System.out.println(" 绘制矩形 ");
	}
}

class Circle extends Shape {

	@Override
	public void draw() {
		// TODO Auto-generated method stub
		System.out.println(" 绘制圆形 ");
	}
}

//新增画三角形
class Triangle extends Shape {

	@Override
	public void draw() {
		// TODO Auto-generated method stub
		System.out.println(" 绘制三角形 ");
	}
}

//新增一个图形
class OtherGraphic extends Shape {

	@Override
	public void draw() {
		// TODO Auto-generated method stub
		System.out.println(" 绘制其它图形 ");
	}
}

迪米特原则

一个对象应该对其他对象保持最少的了解。也成 “最少知道原则”

/**
 * @author 漆剑
 * @date 2021-03-27
 * @description
 */
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 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 CollegeManager {
	//返回学院的所有员工
	public List<CollegeEmployee> getAllEmployee() {
		List<CollegeEmployee> list = new ArrayList<CollegeEmployee>();
		for (int i = 0; i < 10; i++) { //这里我们增加了10个员工到 list
			CollegeEmployee emp = new CollegeEmployee();
			emp.setId("学院员工id= " + i);
			list.add(emp);
		}
		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 emp = new Employee();
			emp.setId("学校总部员工id= " + i);
			list.add(emp);
		}
		return list;
	}

	//该方法完成输出学校总部和学院员工信息(id)
	void printAllEmployee(CollegeManager sub) {

		//分析问题
		//1. 这里的 CollegeEmployee 不是  SchoolManager的直接朋友
		//2. CollegeEmployee 是以局部变量方式出现在 SchoolManager
		//3. 违反了 迪米特法则

		//获取到学院员工
		List<CollegeEmployee> list1 = sub.getAllEmployee();
		System.out.println("------------学院员工------------");
		for (CollegeEmployee e : list1) {
			System.out.println(e.getId());
		}
		//获取到学校总部员工
		List<Employee> list2 = this.getAllEmployee();
		System.out.println("------------学校总部员工------------");
		for (Employee e : list2) {
			System.out.println(e.getId());
		}
	}
}

从上面代码可以看出，这是一个错误示范。
SchoolManager里的printAllEmployee违反了迪米特原则，CollegeEmployee不是SchoolMana
ger的直接朋友
利用迪米特原则改进代码如下：

/**
 * @author 漆剑
 * @date 2021-03-27
 * @description
 */
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 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 CollegeManager {
	//返回学院的所有员工
	public List<CollegeEmployee> getAllEmployee() {
		List<CollegeEmployee> list = new ArrayList<CollegeEmployee>();
		for (int i = 0; i < 10; i++) { //这里我们增加了10个员工到 list
			CollegeEmployee emp = new CollegeEmployee();
			emp.setId("学院员工id= " + i);
			list.add(emp);
		}
		return list;
	}

	//输出学院员工的信息
	public void printEmployee() {
		//获取到学院员工
		List<CollegeEmployee> list1 = getAllEmployee();
		System.out.println("------------学院员工------------");
		for (CollegeEmployee e : list1) {
			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 emp = new Employee();
			emp.setId("学校总部员工id= " + i);
			list.add(emp);
		}
		return list;
	}

	//该方法完成输出学校总部和学院员工信息(id)
	void printAllEmployee(CollegeManager sub) {

		//分析问题
		//1. 将输出学院的员工方法，封装到CollegeManager
		sub.printEmployee();

		//获取到学校总部员工
		List<Employee> list2 = this.getAllEmployee();
		System.out.println("------------学校总部员工------------");
		for (Employee e : list2) {
			System.out.println(e.getId());
		}
	}
}

合成复用原则

尽量使用合成/聚合的方式，而不是使用继承。

因为合成复用原则在其他几个原则中有实例讲解，这里我贴出类图思想以供参考：

在这里插入图片描述

由于水平有限，本博客难免有不足，恳请各位大佬不吝赐教！

我觉得海星_98

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录

设计模式七大原则（设计模式入门必学！也就是设计模式为什么这样设计的依据）

设计模式七大原则

文章目录

单一职责原则

接口隔离原则

依赖倒转原则

里氏替换原则

开闭原则（最基础、最重要的设计原则）

迪米特原则

合成复用原则