设计模式概述-七大软件设计原则_设计模式思想阐述软件

开闭原则、依赖倒置原则、单一职责原则、接口隔离原则、迪米特原则、里氏替换原则、合成（组合）/聚合复用原则

1.开闭原则（Inversion）

软件如类、模块和函数应该对扩展开放，对修改关闭。

用抽象构建框架，用事先扩展细节；面向抽象编程，不面向实现编程。

优点：提供软件系统的可复用性及可维护性；版本更新不修改源代码，可增加新功能。

例子：接口，实现类都无变化；增加子类，即可；

 

 

2.依赖倒置原则

1.高层模块不应该依赖底层模块，两者都应该依赖其抽象；

2.抽象不应该依赖细节；细节应该依赖抽象；

3.针对接口编程，不针对实现编程；

4.相对于细节的多变性，抽象的东西要稳定的多。以抽象结构比细节为基础的架构要稳定的多。

Java中抽象指是接口或抽象类，细节就是具体实现类。

5.使用接口或抽象类的目的是制定好规范，不涉及任何具体的操作，把展现的细节的任务交给实现类来完成

 

优点：减少类间的耦合性、提高系统稳定性；提高代码可读性，可维护性，降低修改程序造成的风险。

例子：采用set接口方法；增加实现接口类；

//完成Person接收消息的功能
//方式1分析
//1. 简单，比较容易想到
//2. 如果我们获取的对象是 微信，短信等等，则新增类，同时Perons也要增加相应的接收方法
//3. 解决思路：引入一个抽象的接口IReceiver, 表示接收者, 这样Person类与接口IReceiver发生依赖
//   因为Email, WeiXin 等等属于接收的范围，他们各自实现IReceiver 接口就ok, 这样我们就符号依赖倒转原则

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

class Email {
    public String getInfo() {
        return "电子邮件信息: hello,world";
    }
}

public class DependecyInversion {

    public static void main(String[] args) {
        //客户端无需改变
        Person person = new Person();
        person.receive(new Email());
        person.receive(new WeiXin());
    }

}

//定义接口
interface IReceiver {
    public String getInfo();
}

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

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

//方式2
class Person {
    //这里我们是对接口的依赖
    public void receive(IReceiver receiver ) {
        System.out.println(receiver.getInfo());
    }
}

微信、邮件都依赖接口IReceiver；依赖倒转，都依赖抽象的接口，而不再依赖具体的实现；

 

依赖关系传递：

1.接口传递

2.构造方法传递

3.setter方式传递

 

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

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

 // 实现接口
 class ChangHong implements ITV {

    @Override
    public void play() {
        System.out.println("长虹电视机，打开");
    }
 }
 // 实现接口
 class OpenAndClose implements IOpenAndClose{
     public void open(ITV tv){  //依赖ITV接口
          tv.play();
     }
 }

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

 

 方式2: 通过构造方法依赖传递
 interface IOpenAndClose {
    public void open(); //抽象方法
 }
 interface ITV { //ITV接口
    public void play();
 }
 
 class ChangHong implements ITV {
    @Override
    public void play() {
        // TODO Auto-generated method stub
        System.out.println("长虹电视机，打开");
    }
}

 class OpenAndClose implements IOpenAndClose{
    public ITV tv; //成员
    public OpenAndClose(ITV tv){ //构造器
    this.tv = tv;
    }
    
    public void open(){
    this.tv.play();
    }
 }
 
 public static void main(String[] args) {
    OpenAndClose openAndClose = new OpenAndClose(changHong);
    openAndClose.open();
 }

// 方式3 , 通过setter方法传递
interface IOpenAndClose {
    public void open(); // 抽象方法

    public void setTv(ITV tv);
}

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

class OpenAndClose implements IOpenAndClose {
    private ITV tv;

    public void setTv(ITV tv) {
        this.tv = tv;
    }

    public void open() {
        this.tv.play();
    }
}

class ChangHong implements ITV {

    @Override
    public void play() {
        // TODO Auto-generated method stub
        System.out.println("长虹电视机，打开");
    }
}

    public static void main(String[] args) {     
        ChangHong changHong = new ChangHong();

        //通过setter方法进行依赖传递
        OpenAndClose openAndClose = new OpenAndClose();
        openAndClose.setTv(changHong);
        openAndClose.open();

    }

 

依赖倒转原则：

1.底层模块尽量都要有抽象类或接口，或者两者都要，程序稳定性更好；

2.变量的声明类型尽量是抽象类或接口，这样在变量引用和实际对象间，存在一个缓冲层，有利于程序扩展和优化；

3.继承时遵循历史替换原则；

 

3.单一职责原则 singleresponsibility（一个类/接口/方法只负责一项职责）

不要存在多于一个导致类变更的原因；

一个类/接口/方法只负责一项职责；

优点：降低类的复杂度、提高类的可读性，降低变更引起的风险；

缺点：会增加接口和方法；

接口单一职责，方法单一职责；

 

//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 + " 在水中行....");
    }
    
    //方法2.
    //..
    //..
    
    //...
}

 

优点：

1.降低类的复杂度，一个类只负责一项职责；

2.提高类的可读性，可维护性；

3.降低变更引起的风险；

4.尽量遵守，可以不在类级别遵守，在方法级别遵守；

 

4.接口隔离原则（Interface Segregation Principle）

定义：用多个专门的接口，而不使用单一的总接口，客户端不应该依赖它不需要的接口。

即一个类对一个类的依赖应该建立在最小的接口上；

建立单一接口，不要建立庞大臃肿的接口；

尽量细化接口，接口汇总的方法尽量少；

注意：适度原则，一定要适度，接口不能太大，也不能太小，是针对抽象的接口。

优点：符合高内聚低耦合的设计思想，从而使得类具有很好的可读性，可扩展性和可维护性；

高内聚减少对外的交互，使用接口中最少的方法实现最多的功能；

低耦合降低依赖，只暴露给调用类的接口，隐藏无用的接口。

 

尽量拆分接口，把一个接口控制在最小；

public class Segregation1 {

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

 

5.迪米特原则

定义：一个对象应该对其特对象保存最少知道原则；

尽量降低类与类之间的耦合，减少类之间的依赖；

优点：降低类之间的耦合；

最少知道，该知道知道，不该知道不知道；尽量减少公开public方法；public变量；尽量使用private，内联；

强调只和朋友交流；不和陌生人说话；方法的输入和输出都是朋友，但方法体内部的类不是朋友；

朋友：出现在成员变量，方法和输入，输出参数中的类；将其称为朋友类；而出现在方法体内部的类不属于朋友类。

耦合的方式：依赖，关联，组合，聚合等；

迪米特法则：

1.核心是降低类之间的耦合；

2.只是减少不必要的依赖，只是降低类间的耦合关系，并不是要去完全没有依赖关系；

 

6.里氏替换原则

问题：

1.子类继承父类的方法不要求强制遵守，但若子类对这些已实现的方法任意修改，会对整体继承体系造成破坏。

2.继承同时带来弊端。要修改父类时，

 

定义：若对每个类型为T1的对象O1，都有类型为T2的对象O2，使得以T1定义的所有程序P在所有的对象O1都替换成O2时，程序P的行为没有发生变化，那么类型T2是类型T1的子类型。即父类可以被子类替换，也就是所有引用基类的地方必须能透明地使用其子类的对象。

在继承时，里氏原则，在子类中尽量不要重写父类的方法；继承使得两个类的耦合性增强了，在适当的情况下，可通过聚合，组合，依赖来解决问题。

定义扩展：一个软件实体若使用一个父类的话，那一定适用于其子类，所有引用父类的地方必须能透明地使用其子类的对象，子类对象能够替换父类对象，而程序逻辑不变。

引申意义：子类可以扩展父类的功能，但不能改变父类原有的功能；

含义1：子类可以实现父类的抽象方法，但不能覆盖父类的非抽象方法。

含义2：子类中可增加自己特有的方法；即子类可以扩展；

含义3：当子类的方法重载父类的方法时，方法的前置条件（即方法的输入/入参）要比父类方法的输入参数更宽松。

含义4：当子类的方法实现父类的方法时（重写/重载或实现抽象方法），方法的后置条件（即方法的输出/返回值）要比父类更严格或相当。

 

优点1：约束继承泛滥，开闭原则的一种体现；

优点2：加强程序的健壮性，同时变更时也可做到非常好的兼容性，提高维护性，降低需求变更引入的风险；

 

问题：

B继承A，然后B重写了A类的方法；造成A类方法调用时出现错误；

 

解决：

A，B都继承一个基类；A，B采用组合的方式，来实现具体的功能；

//创建一个更加基础的基类
class Base {
    //把更加基础的方法和成员写到Base类
}

// A类
class A extends Base {
    // 返回两个数的差
    public int func1(int num1, int num2) {
        return num1 - num2;
    }
}

// B类继承Base，而不是A
// 增加了一个新功能：完成两个数相加,然后和9求和
class B extends Base {
    //如果B需要使用A类的方法,使用组合关系
    private A a = new A();
    
    //B类自定义的方法
    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);
    }
}

这样就不会担心，B类会重写A类的方法，造成A类的方法调用失效；

 

7.合成（组合）/聚合复用原则

定义：尽量使用对象组合/聚合，而不是继承关系达到软件复用的目的；

聚合has-A（有）和组合contains-A（组成，是整体的一部分）。

继承是is-A；

优点：可使系统更加灵活，降低类与类之间的耦合度，一个类的变化对其他类造成的影响较少；

继承是白箱，组合是黑箱；

聚合关系：弱，如电脑和U盘；

组合关系：强，如国家和家；