1.设计模式的七大原则

Posted 2021-07-11 客官不爱喝酒

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了1.设计模式的七大原则相关的知识，希望对你有一定的参考价值。

图解java设计模式

1.简介

通过本文章，你可以了解到常用的设计模式，本文的设计模式都是通过java语言进行讲解的，这也是我个人的一个学习笔记，设计模式以及数据结构和算法可能实际开发中用不到，但是这是程序员的基本功，这也就是你看框架源代码的时候头晕，看不懂，不知道别人到底写的什么玩意儿。那么你该静下心来好好学习基础知识了，记住一句话，罗马不少一天建成的，万丈高楼平地其，一切都以基础为准，框架层出不穷，但是万变不离其宗，都是以我们的核心基础知识来的。学完设计模式，你对写代码的一个水平会有一个很好的提升。

我看的是韩顺平老师讲的
课程地址如下：https://www.bilibili.com/video/BV1G4411c7N4

课程资料：

链接：https://pan.baidu.com/s/1zKvmp3TUQG30KJyUCAQ1_Q
提取码：psoc

1、设计模式的目的

编写软件过程中，程序员面临着来自耦合性，内聚性以及可维护性，可扩展性，重用性，灵活性等多方面的挑战，设计模式是为了让程序(软件)，具有如下更好的特性

设计模式在软件中哪里？

面向对象(oo)=>功能模块[设计模式+算法(数据结构)]=>框架[使用到多种设计模式]=> 架构 [服务器集群]

代码重用性 (即：相同功能的代码，不用多次编写)
可读性 (即：编程规范性，便于其他程序员的阅读和理解)
可扩展性 (即：当需要增加新的功能时，非常的方便，称为可维护)
可靠性 (即：当我们增加新的功能后，对原来的功能没有影响)
使程序呈现高内聚，低耦合的特性(程序内部紧凑，模块之间依赖性小)

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

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

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

1.单一职责原则

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

就比如说我们的javaWeb开发的到层，一个UserDao就对用户表增删改查，一个OrderDao就对我们的订单表增删改查，如果UserDao和OrderDao的功能都放到一个类只能，那么就可能会出现，UserDao出现错误导致OrderDao也不能用。所以我们就需要使用单一职责，让一个类做一个事情，降低代码的耦合度，使其代码之间的依赖性不少那么强。

单一职责案例

错误案例1：这的逻辑是不对的，造成代码的逻辑混乱

/** 单一职责
 * @author compass
 * @version 1.0
 * @date 2021-07-04 0:34
 */
public class SingleResponsibility1  {
    public static void main(String[] args) {
        Vehicle vehicle = new Vehicle();
        vehicle.run("摩托车");
        vehicle.run("汽车");
        vehicle.run("飞机");
    }
}

/**
 * 交通工具类Vehicle
 * 1. 这种方式违反了单一职责
 * 2.解决的方案非常简单，根据不同的交通工具分解未不同的类 提供run方法
 */
class Vehicle{

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

}

解决思路：将业务进行拆分，就是根据不同的业务，构建出不同的类，让不同的类去做不同的事情，让他们互不影响。

正确案例2：但是这样做改动很大，即将类进行分解，同时会修改客户端，接下来我们看第三种改进的方式。

/** 单一职责（正确示范）
 * @author compass
 * @version 1.0
 * @date 2021-07-04 0:34
 */
public class SingleResponsibility2  {
    public static void main(String[] args) {

        RoadVehicle roadVehicle = new RoadVehicle();
        roadVehicle.run("汽车");

        WaterVehicle waterVehicle = new WaterVehicle();
        waterVehicle.run("轮船");

        AirVehicle airVehicle = new AirVehicle();
        airVehicle.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+"在水中运行");
    }

}

改进方案3：直接修改Vehicle类，改动的代码比较少

/** 单一职责（错误示范）
 * @author compass
 * @version 1.0
 * @date 2021-07-04 0:34
 */
public class SingleResponsibility3  {
    public static void main(String[] args) {
        Vehicle3 vehicle = new Vehicle3();
        vehicle.runARoad("汽车");
        vehicle.runAir("飞机");
        vehicle.runWater("轮船");
    }
}

/**
 * 交通工具类Vehicle3
 * 1. 这种方式虽然违反了单一职责，但是在方法级别上并没有违法单一职责，仍然遵守我们的单一职责
 * 2.在业务量很小的时候，可以这样，但是业务量很多，而且不同类型很多，那就不太建议了
 */
class Vehicle3{

    public void runAir(String vehicle){
        System.out.println(vehicle+"在天上运行");
    }
    public void runWater(String vehicle){
        System.out.println(vehicle+"在水里运行");
    }

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


}

单一职责原则的注意事项和原则
1. 降低类的复杂度，一个类只负责一项职责
2. 提高类的可读性，可维护性
3. 降低变更引起的风险
4. 通常情况下，我们应当遵守单一职责原则，只有逻辑足够简单，才可以在代码级违反单一职责原则；只有类中方法数量足够少，可以在方法级别保持单一职责原则

2.接口隔离原则

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

举例说明

案例1：

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

代码实现：

** 接口隔离原则（错误示范）
 * @author compass
 * @version 1.0
 * @date 2021-07-04 11:35
 */
public class Segregation1 {

}

/**
 *  接口
 */
interface Interface1{
    void operation1();
    void operation2();
    void operation3();
    void operation4();
    void operation5();

}

/**
 *  实现interface1接口 并且实现其中的五个方法
 */
class B1 implements Interface1{

    @Override
    public void operation1() {
        System.out.println("B1 中实现了operation1");
    }

    @Override
    public void operation2() {
        System.out.println("B1 中实现了operation2");
    }

    @Override
    public void operation3() {
        System.out.println("B1 中实现了operation3");
    }

    @Override
    public void operation4() {
        System.out.println("B1 中实现了operation4");
    }

    @Override
    public void operation5() {
        System.out.println("B1 中实现了operation5");
    }
}
/**
 *  实现interface1接口 并且实现其中的五个方法
 */
class D1 implements Interface1{

    @Override
    public void operation1() {
        System.out.println("D1 中实现了operation1");
    }

    @Override
    public void operation2() {
        System.out.println("D2 中实现了operation2");
    }

    @Override
    public void operation3() {
        System.out.println("D3 中实现了operation3");
    }

    @Override
    public void operation4() {
        System.out.println("D4 中实现了operation4");
    }

    @Override
    public void operation5() {
        System.out.println("D5 中实现了operation5");
    }
}
/**
 *  A类通过接口 Interface1 依赖使用B类 但是只会使用到 1，2，3，方法
 */
class A1{
    public void depend1(Interface1 i){
        i.operation1();

    }

    public void depend2(Interface1 i){
        i.operation2();

    }
    public void depend3(Interface1 i){
        i.operation3();

    }
}


/**
 *  C类通过接口 Interface1 依赖使用D类 但是只会使用到 1，4，2，方法
 */
class C1{
    public void depend1(Interface1 i){
        i.operation1();

    }

    public void depend4(Interface1 i){
        i.operation4();

    }
    public void depend5(Interface1 i){
        i.operation5();

    }
}

案例2：

分析传统方法的问题，使用接口隔离原则改进程序结构

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

代码实现：

/** 接口隔离原则（正确示范）
 * @author compass
 * @version 1.0
 * @date 2021-07-04 11:35
 */
public class Segregation2 {

    public static void main(String[] args) {


        A a = new A();
        a.depend1(new B()); // A类通过接口去依赖B类
        a.depend2(new B());
        a.depend3(new B());

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

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

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)是指：

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

案例1：

未遵循依赖倒置原则，Person 类与 Email 类耦合，如果我们还想获取其他消息，比如微信、短信、QQ 等、则需要添加相应的实现方法

/** 接口依赖倒置原则
 * @author compass
 * @version 1.0
 * @date 2021-07-04 13:37
 */
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分析
//1. 简单，比较容易想到
//2. 如果我们获取的对象是 微信，短信等等，则新增类，同时Peron也要增加相应的接收方法
//3. 解决思路：引入一个抽象的接口IReceiver, 表示接收者, 这样Person类与接口IReceiver发生依赖
//   因为Email, WeiXin 等等属于接收的范围，他们各自实现IReceiver 接口就ok, 这样我们就符号依赖倒转原则
class Person {
    public void receive(Email email) {
        System.out.println(email.getInfo());
    }
}

案例2：

引入一个抽象的接口 IReceiver，表示接收者（Email、微信、短信、QQ 等），接受者分别实现 IReceiver 接口中的方法，实现各自接收消息的逻辑，Person 类与 IReceiver 接口发生依赖，达到接收消息的功能

/** 接口依赖倒置原则
 * @author compass
 * @version 1.0
 * @date 2021-07-04 13:37
 */
public class DependencyInversion2 {
    public static void main(String[] args) {
        Person2 person2 = new Person2();
        person2.receive(new Email2());
        person2.receive(new WeiXin());
    }
}

interface IReceiver{
    public String getInfo();
}

class Email2 implements IReceiver {
    public String getInfo() {
        return "电子邮件信息: hello,world";
    }
}
//增加微信
class WeiXin implements IReceiver {
    public String getInfo() {
        return "微信信息: hello,ok";
    }
}



class Person2 {
    public void receive( IReceiver receiver) {
        System.out.println(receiver.getInfo());
    }
}

依赖关系传递的三种方式和应用案例:

1、接口传递

public class DependencyPass {

	public static void main(String[] args) {
		// 通过接口传递
		ChangHong changHong = new ChangHong();
		OpenAndClose openAndClose = new OpenAndClose();
		openAndClose.open(changHong);
	}

}

// 方式1： 通过接口传递实现依赖
// 开关的接口
interface IOpenAndClose {
	public void open(ITV tv); // 抽象方法,接收接口
}

// ITV接口
interface ITV {
	public void play();
}

// 长虹电视：实现 ITV 接口
class ChangHong implements ITV {
	@Override
	public void play() {
		System.out.println("长虹电视机，打开");
	}
}

// 设备播放类：实现 IOpenAndClose 接口，调用接口 IITV 的 play() 方法实现播放功能（通过接口注入）
class OpenAndClose implements IOpenAndClose {
	public void open(ITV tv) {
		tv.play();
	}
}

2、构造方法传递

public class DependencyPass {

	public static void main(String[] args) {
		// 通过构造器进行依赖传递
         ChangHong changHong = new ChangHong();
		OpenAndClose openAndClose = new OpenAndClose(changHong);
		openAndClose.open();
	}

}

// 方式2: 通过构造方法依赖传递
interface IOpenAndClose {
	public void open(); // 抽象方法
}

interface ITV { // ITV接口
	public void play();
}

// 长虹电视：实现 ITV 接口
class 以上是关于1.设计模式的七大原则的主要内容，如果未能解决你的问题，请参考以下文章 
 设计模式软件设计七大原则 ( 依赖倒置原则 | 代码示例 )
 设计模式软件设计七大原则 ( 迪米特原则 | 代码示例 )
 设计模式软件设计七大原则 ( 接口隔离原则 | 代码示例 )
 设计模式软件设计七大原则 ( 合成复用原则 | 代码示例 )
 解密设计模式的七大原则
 设计模式软件设计七大原则 ( 里氏替换原则 | 代码示例 | 类示例 | 方法入参示例 | 方法返回值示例 )