设计模式概述

设计模式的目的

• 代码可重用性（相同功能的代码，不用多次编写）
• 可读性（编程规范性）
• 可扩展性（增加新的功能时，非常方便，可维护）
• 可靠性（增加新的功能，对原来的功能没有影响）
• 使程序呈现高内聚，低耦合的特性

设计模式的七大原则

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

1、单一职责原则

基本介绍：
对类来说，即一个类应该只负责一项职责。如果A类负责两个不同职责：职责1，职责2，当职责1需求改变二改变A时，可能造成职责2执行错误，所以需要将类A的粒度分为A1，A2，
注意事项和细节：
1、降低类的复杂度，一个类只负责一项职责
2、提高类的可读性，可维护性
3、降低变更引起的风险
4、通常情况下，我们应当遵守单一职责原则，只有逻辑足够简单，才可以在代码级违反单一职责原则；只有在类中方法数量足够少，可以在方法级别保持单一职责原则

2、接口隔离原则

基本介绍：
客户端不应该依赖他不需要的接口，即一个类对一个类的依赖应该建立在最小接口上。
例如：
有一个A类需要通过接口interface依赖类B，但是只是用到了类B中的三个方法，但是类B实现了接口的所有方法。这样子接口对于B来说并不是最小接口

改进：
将接口拆分成独立的几个接口，类A只需要的接口建立依赖关系，这就是采用接口隔离原则

3、依赖倒转原则

基本介绍

实例

/*这种情况下，但我们需要扩展程序时，如添加其他信息，qq信息，微信消息等时，需要修改person的类，或者是新增
* 解决的思路是：   引入一个抽象的接口，表示接受者，这样Person类与接口发生依赖，这样只要相对应的消息类实现接口就
* 可以了，这就是依赖反转*/
public class DependecyInversion {
    public static void main(String[] argss) {
    Person person = new Person();
    person.receive(new Email());
    //新增一个QQ
        person.receive(new QQ());//利用接口，就可以不用修改Person类
    }
}
//定义一个接口
interface  Receive{
    String getInfo();
}
//定义邮件类,实现Receive接口
class Email implements Receive{
    public String getInfo(){
        return "这是一个email";
    }
}
//添加一个QQ
class QQ implements Receive{

    @Override
    public String getInfo() {
        return "这是一个QQ消息";
    }
}
//完成Person接受消息
class Person{
    public void receive(Receive receive){//将Person与接口发生依赖
        System.out.println(receive.getInfo());
    }
}

注意事项和细节：
1、底层模块尽量都要有抽象类或者接口，程序稳定性好一点
2、变量的声明类型尽量是抽象类或接口，这样我们的变量引用和实际对象间，就存在一个缓冲层，利于程序的扩展和优化
3、继承是遵循里氏替换原则

里式替换原则

基本介绍

注意点：尽量不要重写父类方法，尽可能通过聚合，组合，依赖来替代继承（适配器模式的对象适配器），也可以把两个不同的类相同的函数提升到更加基础的父类，降低两个类的耦合。

//使用里式替换解决之间的耦合性
public class lisKovImprove {
    public static void main(String[] args) {
        A a = new A();
        System.out.println(a.func1(1,2));//使用A类的func1
        B b = new B();
        System.out.println(b.func1(1,2));//很明确的使用B类的func1，不会因为继承的原因增加A和B类之间的耦合
    }
}
//将A和B类的共同点抽象成一个更加基础的父类
class Base{

}
class A extends Base{
    public int func1(int num1,int num2){
        return num1-num2;
    }
}
//类B继承A类
class B  extends Base{
    //使用继承会使代码具有侵入性，可能会造成系统的不稳定
    //模拟不小心重写父类的func1方法，
    public int func1(int num1,int num2){
        return num1+num2;
    }
    public int func2(int num1,int num2){
        return num1*num2;
    }
}

开闭原则

基本介绍
1、开闭原则（Open Closed Principle）是编程中最基础最重要的设计原则
2、一个软件实体如类，模块和函数应该对扩展开放（增加类，针对提供方），对修改关闭（使用方）。用抽象架构框架，用实现扩展细节。
3、当软件需要变化时，尽量通过扩展软件实体行为来实现变化， 而不是通过修改已有代码来实现。
4、编程中遵守其他原则，以及使用设计模式的目的就是遵循开闭原则

实例代码：

//使用开闭原则，将graph抽象成一个接口，让所有
// 的图形类实现该接口，这样使用方GraphicEditor在添加新的类的时候就不需要修改代码，体现了扩展开放，修改关闭的开闭原则
public class Ocp {
    public static void main(String[] args) {
        GraphicEditor graphicEditor = new GraphicEditor();
        graphicEditor.drawShape(new Rectangle());
        graphicEditor.drawShape(new Circle());
        graphicEditor.drawShape(new other());
    }
}
//使用方
class GraphicEditor{
    //参数为接口，根据传入的接口判断打印哪一个类型，这样就降低耦合度，不需要修改代码
    public void drawShape(Graph graph){
       graph.draw();
    }
}
//定义图形类，实现打印的类
interface Graph{
    void draw();
}
//定义一个矩形类
class Rectangle implements Graph{
    @Override
    public void draw() {
        System.out.println("打印矩形");
    }
}
//定义一个圆形类
class Circle implements Graph{
    @Override
    public void draw() {
        System.out.println("打印圆形");
    }
}

class other implements  Graph{

    @Override
    public void draw() {
        System.out.println("打印其他");
    }
}

迪米特法则

基本介绍
1、一个对象应该对另外一个对象保持最小的了解
2、类与类之间关系越密切，耦合度越大
3、迪米特法则又叫最小知道原则,即一个类对自己依赖的类知道的越少越好，也可以说，被依赖的类不管有多复杂，都尽量将逻辑封装在类的内部，不对外泄漏任何信息
4、只于最直接的盆友通信
5、直接的朋友：每个对象都会与其他对象有耦合关系，只要两个对象之间有耦合关系，我们就说这两个对象之间是朋友关系。耦合的方式有很多，依赖，关联，组合，聚合等，其中，我们称出现的成员变量，方法参数，方法返回值中的类为直接朋友，而出现在局部变量中的类不是直接朋友。也就是说，陌生的类最好不要以局部变量的形式出现在类内部。，方法中尽量不要new一个不是该类直接朋友的变量。

合成复用原则

基本介绍
原则是尽量使用合成/聚合方式，而不是使用继承

设计模式的核心思想

1、找出应用中可能需要变化之处，把他们独立出来，不要和那些不需要变化的代码混在一起
2、针对接口编程，而不是针对实现编程
3、为了交互对象之间的松耦合设计而努力