设计模式的原则

设计模式有七大原则

1）单一职责原则

基本介绍：

一个类只负责一项职责

也可以在方法级别实现

2）接口隔离原则

 客户端不应该依赖它不需要的接口

public class IntefaceIsolation {

    public static void main(String[] args) {
        C c = new C();
        //c类通过接口A依赖A类
        c.dependA(new A());
        //c类通过接口B依赖B类
        c.dependB(new B());
    }
}

interface  interfaceA{
    void segregate1();
    void segregate2();
}
interface interfaceB{
    void segrefate3();
    void segrefate4();
}

interface interfaceC{
    void segregate1();
    void segregate4();
}

class A implements interfaceA{

    @Override
    public void segregate1() {
        System.out.println("A实现了A接口方法1");
    }

    @Override
    public void segregate2() {
        System.out.println("A实现了A接口方法2");
    }
}

class B implements interfaceB,interfaceC{

    @Override
    public void segrefate3() {
        System.out.println("B实现了B接口方法1");
    }

    @Override
    public void segrefate4() {
        System.out.println("B实现了B接口方法2");
    }

    @Override
    public void segregate1() {
        System.out.println("B实现了C接口方法2");
    }

    @Override
    public void segregate4() {
        System.out.println("B实现了C接口方法2");
    }
}

class C {
    void dependA(interfaceA a){
        a.segregate1();
        a.segregate2();
    }
    void dependB(interfaceB b){
        b.segrefate3();
        b.segrefate4();
    }
}

A实现了A接口方法1
A实现了A接口方法2
B实现了B接口方法1
B实现了B接口方法2

通过接口对实现类产生依赖

通过接口的分离方法1和方法2，而不依赖接口C中的方法

C类只依赖B类的

3）依赖倒置原则

高层模块不应该依赖低层模块，二者都应该依赖其抽象

抽象不应该依赖细节，细节应该依赖抽象

依赖倒转的中心思想是面向接口编程

接口依赖

构造方法依赖

setter方式依赖

4）里氏替换原则

解决的问题是：如何正确的使用继承

尽量不要重写父类的方法

继承实际上让两个类耦合性增强了，在适当的情况下，可以通过聚合，组合，依赖来解决问题

5）开闭原则

对扩展开放（提供方），对修改关闭（使用方）

用抽象构建框架，用实现扩展细节

public class OpenClosePattern {
    public static void main(String[] args) {
        drawDesigns drawDesigns = new drawDesigns();
        drawDesigns.drawShape(new drawCircle());
        drawDesigns.drawShape(new drawSquare());
    }
}
abstract class Shape {
    abstract void draw();
}

class drawDesigns {
    public void drawShape(Shape shape) {
        shape.draw();
    }
}

class drawCircle extends Shape{

    @Override
    void draw() {
        System.out.println("画一个圆形");
    }
}
class drawSquare extends Shape{

    @Override
    void draw() {
        System.out.println("画一个正方形");
    }
}
class drawTriangle extends Shape{

    @Override
    void draw() {
        System.out.println("画一个三角形");
    }
}

 当要新增一个新的图形的时候，只需要集成抽象类就可以，不需要修改画图的类，实现了可扩展

6）迪米特法则

一个对象应该对其他对象保持最小的了解

类与类关系越密切，耦合度越大

最少知道原则

直接朋友：

  1、B类是A类的成员方法

  2、B类作为参数传给A类的方法

  3、B类是A类方法的返回类型

不在以上关系之中的就不是直接朋友

7）合成复用原则

尽量使用合成/聚合 少用继承

聚合：

 A类要使用B类的方法1和方法2，那么可以通过将B类作为A类的一个成员变量来使用，这种方式叫做聚合

合成：

 B类要用A类的方法1和方法2，只需要在B类中创建一个A类即可

 设计模式的分类

1）创建型设计模式：单例模式、抽象工厂模式、原型模式、建造者模式、工厂模式

2）结构型模式：适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式

3）行为型模式：模板方法模式、命令模式、访问者模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式、状态模式、策略模式、责任链模式