本文共 3745 字，大约阅读时间需要 12 分钟。

设计模式

一、设计模式中的六大原则

1.1 单一职责原则

​ 一个类只负责一个功能领域的相应职责

​ 实现：高内聚，低耦合

​ 高内聚：尽可能每个类成员方法只完成一件事

​ 低耦合：减少内部 一个成员方法调用另外一个成员

1.2 开闭原则

​ 对增加进行开放，对修改则关闭

1.3 里氏替换原则LSP

​ 1.任何有**基类（父类）**出现的地方，子类一定可以出现

​ 2.程序中尽量使用基类来定义对象，在运行的时候再来确定子类

1.4依赖倒转原则

​ 1.针对接口编程，依赖于抽象而不依赖于具体

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

1.5接口隔离原则

​ 1.客户端不应该依赖于它不需要的接口

​ 2.使用多个隔离接口，降低类之间的耦合性

1.6迪米特法则

​ 1.最少知道原则，一个类应对尽量少的知识与其他类发生的相互作用

​ 2.合理引入一个第三者来降低现有对象之间的耦合度

二、设计模式之单例模式

2.1 饿汉模式

​ 饿汉模式就是在类加载的时候就将这个对象新建

​ 1.新建对象并且赋值

​ 2.新建私有的无参构造方法

​ 3.提供一个公共的静态方法来获取对象

​

public class SingletonHungry {
       /**     *  JDK中Runtime类 饿汉方式     *     *  类加载的时候就创建一个对象，比较占用内存     */    private static final SingletonHungry instance = new SingletonHungry();    /**     *  私有构造方法     */    private SingletonHungry () {
   }    public static SingletonHungry getInstance() {
           return instance;    }}

2.2 懒汉模式

​ 懒汉模式就是在第一次需要对象的时候才会新建对象

​ 1.新建一个字段不赋值

​ 2.新建私有的无参构造方法

​ 3.提供一个公共的静态方法来获取对象

public class SingletonLazy {
       /**     *     *       这是否安全，instance = new SingletonLazy(); 并不是原子性操作     *       1、分配空间给对象     *       2、在空间内创建对象     *       3、将对象赋值给引用instance     *          *       假如线程 1-》3-》2顺序，会把值写会主内存，其他线程就会读取到instance最新的值，但是这个是不完全的对象     *       (指令重排)     *     *      volatile是Java提供的关键字，它具有可见性和有序性，     *           *       指令重排序是JVM对语句执行的优化，只要语句间没有依赖，那JVM就有权对语句进行优化     */    private volatile static  SingletonLazy instance;    private SingletonLazy(){
   }    /**     * DCL 双重检查锁定 （Double-Checked-Locking）,在多线程情况下保持高性能     *     */    public static SingletonLazy getInstance() {
           // 第一重检查        if (instance != null) {
               // 加锁            synchronized (SingletonLazy.class) {
                   // 第二重检查                if (instance != null) {
                       instance = new SingletonLazy();                }            }        }        return instance;    }}

三、工厂模式

3.1简单工厂模式

3.2工厂方法模式

3.3抽象工厂模式

四、适配器模式

4.1 类适配器模式

4.2 API适配器模式

五、原型设计模式prototype

原型设计模式：prototype

浅拷贝：浅拷贝 对于 引用类型的变量，会拷贝其【指向的地址】

需要实体类实现 Cloneable

@Overrideprotected Person clone() throws CloneNotSupportedException {
       return (Person) super.clone();}

深拷贝：深拷贝 对于 引用类型的变量，则会拷贝其变量本身的值 而不是地址

需要实体类实现 Serializable

protected Person deepClone() {
       try {
         // 输出 序列化      ByteArrayOutputStream baos = new ByteArrayOutputStream();      ObjectOutputStream oos = new ObjectOutputStream(baos);      oos.writeObject(oos);      // 输入 反序列化      ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());      ObjectInputStream ois = new ObjectInputStream(bais);      Person copyPerson = (Person) ois.readObject();      return copyPerson;    } catch (Exception e) {
         e.printStackTrace();      return null;    }  }

六、建造者模式

建造者模式：

​ 通过builder定义接口，然后不同类型的实体类来实现， 然后通过 构建者来创建，对接的实体

七、桥接模式

不同的手机有不同的业务：

八、装饰者模式

九、装饰者模式

十、外观设计模式

十一、策略 模式

十二、模板模板

public abstract class AbstractProjectManager {
       /**     *  模板方法，执行方法     */    public final void processProject() {
           review();        design();        coding();        test();        online();    }    public void review(){
           System.out.println(">>>>>> 项目需求评审");    }    public void design(){
           System.out.println(">>>>>>>>>> 需要设计");    }    /**     * 抽象方法，每个编码不一样     */    public abstract void coding();    /**     * 抽象方法，具体类子类进行实现，测试有多种     */    public abstract void test();    /**     * 抽象，上线有全量发布，有灰度发布     */    public abstract void online();}

public class PayServiceProjectManager extends AbstractProjectManager {
       @Override    public void coding() {
           System.out.println(">>>>>> 支付项目30天");    }    @Override    public void test() {
           System.out.println(">>>>>>>>>> 功能测试、安全测试");    }    @Override    public void online() {
           System.out.println(">>>>>>>> 全量测试");    }}

十三、观察者模式

十四、责任链模式

十五、命令模式

十六、迭代器设计模式

转载地址：http://yexxi.baihongyu.com/