设计模式

1、设计模式三大类

​ 创建型模式： 工厂模式，单例模式。。。

​ 结构型模式： 代理模式。。。

​ 行为型模式： 观察者模式。。。

2、设计模式六原则

​ 总原则：开闭原则

​ 对拓展开放，对修改关闭。在程序需要扩展的时候，不能修改之前的代码。使用接口和抽象类等实现。

1. 单一职责原则

​ 一个类实现一个单一的职责，如果职责多，就分多个类写。

2. 里氏替换原则

​ 子类对父类的方法尽量不要重载或重写。

3. 依赖倒转原则

​ 面向接口编程。

4. 接口隔离原则

​ 每个接口中不存在子类必须实现却没有用的方法。如果有，就将接口拆分。

5. 迪米特法则（最少知道原则）

   一个类对自己依赖的类知道的越少越好，不关心其他类的内部实现逻辑。

6. 合成复用原则

​ 尽量使用合成/聚合方式，避免继承。

3、三个基本设计模式

3.1 工厂模式

​ 本质上就是创建对象，集中管理对象，代码解耦。

public interface Student {
    public abstract void say();
}

public class fg implements Student
{
    @Override
    public void say() {
        // TODO Auto-generated method stub
        System.out.println("i am fg");
    }
}

public class fan implements Student
{
    @Override
    public void say() {
        System.out.println("i am fan");
    }
}

public interface Provider {
    public abstract Student getSay();
}

public class fgProvider implements Provider
{
    @Override
    public Student getSay() {
        // TODO Auto-generated method stub
        return new fg();
    }
}

public class fanProvider implements Provider
{
    @Override
    public Student getSay() {
        // TODO Auto-generated method stub
        return new fan();
    }
}

public static void main(String[] args) {
        Provider provider = new fgProvider();
        Student student = provider.getSay();
        student.say();
}

​ 如果想要增加一个功能，就创建一个类实现Student接口，在创建一个类实现Provider。不用修改别的代码，扩展性好。

3.2 单例模式

​ 某些类的创建会比较频繁，对于一些大型的对象，是很大的一笔开销。

public class Single1 
{
    private final static Single1 single1 = new Single1();

    private Single1() {}

    public static Single1 getInstance()
    {
        return single1;
    }
}

3.3 代理模式

​ 增加代理类，处理额外的操作。

public class Proxy implements Student
{
    private Student student;

    public Proxy(Student student) 
    {
        super();
        this.student = student;
    }

    @Override
    public void say() {
        student.say();
        after();
    }
    public void after()
    {
        System.out.println("123123");
    }

}


main:
        Student student2 = new fg();
        student2 = new Proxy(student2);
        student2.say();

适配器模式

​ 就是将类的接口转化为用户期望的另一个接口，目的是为了消除接口不匹配的类的兼容性问题。 IO

装饰器模式

​ 装饰器模式就是给一个对象增加额外的功能，动态的将功能增加到对象上。 IO

桥接模式

​ 将抽象化和实现化解耦，使得二者可以动态变化。 JDBC中的DriverManager

享元模式

​ 主要目的是实现对象的共享，即共享池。当系统中对象多的时候可以减少系统开销，通常与工厂模式配合使用。

责任链模式

​ 很多个对象，每个对象都持有对下一个对象的引用。请求在这条链上传递，直到有一个对象决定处理这个请求。但是发出者不知道是哪个对象处理的。

​ 应用场景：在隐瞒客户端的时候，对系统进行动态的调整。