设计模式—— 七大设计原则

Posted 2022-10-12 玛丽莲茼蒿

设计模式都是遵循以下7个原则去设计的：

1. 单一职责原则
2. 接口隔离原则
3. 依赖倒置原则（面向接口编程原则）
4. 里式替换原则
5. 开闭原则
6. 迪米特法则
7. 合成复用原则

一、单一职责原则

定义：在类的级别上，一个类只负责一项职责；在方法的级别上，一个方法只做一件事。

二、接口隔离原则

定义：一个类对另一个类的依赖应该建立在最小接口上。

举个违反接口隔离原则的例子：

 类A通过接口Interface1依赖类B，类C通过接口Interface1依赖类D（看了代码就明白了）。

package HeadFirst;

/**
 * 【违反】接口隔离原则的例子
 */
public class InterfaceIsolationTest 
    public static void main(String[] args) 
        //
        B b = new B();
        A a = new A();
        a.test1(b);
        a.test2(b);
        a.test3(b);
        //
        D d = new D();
        C c = new C();
        c.test1(d);
        c.test4(d);
        c.test5(d);
    


interface Interface1
    void operation1();
    void operation2();
    void operation3();
    void operation4();
    void operation5();


//类B实现接口Interface1
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");
    


//类D实现接口Interface1
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");
    


//类A 通过接口依赖类B
class A
    public void dependB1(Interface1 i)
        i.operation1(); //B的operation1
    
    public void dependB2(Interface1 i)
        i.operation2();//B的operation2
    
    public void dependB3(Interface1 i)
        i.operation3();//B的operation3
    


//类C 通过接口依赖类D
class C
    public void dependD1(Interface1 i)
        i.operation1();//D的operation1
    
    public void dependD4(Interface1 i)
        i.operation4();//D的operation4
    
    public void dependD5(Interface1 i)
        i.operation4();//D的operation5
    

类A只需要使用类B对接口的1/2/3个实现，但是B却实现了接口全部方法；同样，类C只需要使用类D对接口的1/4/5个实现，但是D也实现了接口的全部方法。对B来说，方法4和5是完全没必要实现的，对D来说方法2和3是完全没必要实现的。

按照【接口隔离】原则，划分出3个【最小接口】：

 

 

 

 三、依赖倒置原则

定义：

核心思想：面向接口编程，而不是面向具体的实现类编程

3.1 例子

这是之前就体会到也是【最常见】的一种原则 。

什么是依赖？Person类在其方法中使用了另一个类——Email类，就是Person类依赖于Email类。

如果Person类还要接收微信消息、QQ消息，就要对receive方法进行重载。所以面向接口编程就是为了解决大量重载的问题，缩短代码量。

 解决：

 3.2 依赖倒置的三种使用方法/依赖传递的3种方法

还是先弄清被传递的【依赖】是谁？在下面这个例子中，DriverOne类中使用了车的接口ICar，也就是司机依赖于车，所以被传递的依赖是【车】

1. 接口传递

package HeadFirst;

public class Priciple 
    public static void main(String[] args) 
        NISSAN nissan = new NISSAN();
        DriverOne driver = new DriverOne();
        driver.drive(nissan); //通过接口传递依赖
    


interface ICar
    public void run();


interface IDriver
    public void drive(ICar car); //接口IDriver 依赖于 接口ICar


class DriverOne implements IDriver
    @Override
    public void drive(ICar car) 
        car.run();
    


class NISSAN implements ICar
    @Override
    public void run() 
        System.out.println("尼桑在跑了");
    

2. 构造方法传递

构造方法传递和setter方法的思路是一样的。直接把依赖的【车】定义为自己的成员变量。

package HeadFirst;

public class Priciple 
    public static void main(String[] args) 
        NISSAN nissan = new NISSAN();
        DriverOne driver = new DriverOne(nissan);//构造方法传递依赖
        driver.drive();
    


interface ICar
    public void run();


interface IDriver
    public void drive();


class DriverOne implements IDriver
    ICar car;   //把依赖的车直接定义为成员变量
    DriverOne(ICar car)
        this.car = car; //构造方法里传递依赖
    
    @Override
    public void drive() 
        car.run();
    


class NISSAN implements ICar
    @Override
    public void run() 
        System.out.println("尼桑在跑了");
    

3. setter方法传递

直接把依赖的【车】定义为自己的成员变量，但不在构造方法里传递依赖，而是再写一个专门传递依赖的setter方法。

package HeadFirst;

public class Priciple 
    public static void main(String[] args) 
        NISSAN nissan = new NISSAN();
        DriverOne driver = new DriverOne();//构造方法传递依赖
        driver.setCar(nissan);
        driver.drive();
    


interface ICar
    public void run();


interface IDriver
    public void drive();


class DriverOne implements IDriver
    ICar car;   //把依赖的车直接定义为成员变量
    @Override
    public void drive() 
        car.run();
    

    public void setCar(ICar car)  //setter传递依赖
        this.car = car;
    


class NISSAN implements ICar
    @Override
    public void run() 
        System.out.println("尼桑在跑了");