白话讲解设计模式（常见11个）

设计模式（常见11个）

七大原则

单一原则

一个类一个职责

开闭原则

拓展开放，修改封闭

里氏替换

开闭原则的补充，父亲出现的地方，子类一定可以出现

原理：抽象化实现

依赖倒转原则

依赖接口，补依赖实现，即：抽象编程，解耦

接口隔离原则

不同不能在不同的接口，这样避免接口之间产生不必要依赖

合成/聚合复用原则

通过引入（注入）对象来达到某些目的而不要去继承类

迪米特法则

减少对象的相互作用和依赖，模块独立

单列模式（重要）

创建型模式

懒汉式（线程安全）

public class Singleton2 {

    private static Singleton2 instance;

    private Singleton2() {}

    public static synchronized Singleton2 getInstance() {
        if (instance == null) {
            instance = new Singleton2();
        }

        return instance;
    }

}

饿汉式（线程安全）

public class Singleton3 {

    private static Singleton3 instance = new Singleton3();

    private Singleton3() {}

    public static Singleton3 getInstance() {
        return instance;
    }

} 

双检锁/双重校验锁 + volatile关键字

public class Singleton7 {

    private static volatile Singleton7 instance = null;

    private Singleton7() {}

    public static Singleton7 getInstance() {
        if (instance == null) {
            synchronized (Singleton7.class) {
                if (instance == null) {
                    instance = new Singleton7();
                }
            }
        }
        return instance;
    }
}

静态内部类实现

静态内部类在JVM中式唯一的，很好的保证了单例的特性

public class Singleton{
    private static class SingletonHolder{
        private static final Singleton INSTANCE=new Singleton();
    }
    private Singleton(){
        
	}
    public static final Singleton getInstance(){
		return SingletonHolder.INSTANCE;
    }
}

工厂模式

创建型模式

意图：定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行

ShapeFactory shapeFactory = new ShapeFactory();

        //获取 Circle 的对象，并调用它的 draw 方法
        Shape shape1 = shapeFactory.getShape("CIRCLE");
        //调用 Circle 的 draw 方法
        shape1.draw();

        //获取 Rectangle 的对象，并调用它的 draw 方法
        Shape shape2 = shapeFactory.getShape("RECTANGLE");
        //调用 Rectangle 的 draw 方法
        shape2.draw();

        //获取 Square 的对象，并调用它的 draw 方法
        Shape shape3 = shapeFactory.getShape("SQUARE");
        //调用 Square 的 draw 方法
        shape3.draw();

抽象工厂模式

抽象接口工厂，又叫超级工厂，实现接口创建不同的工厂对象，工厂对象创建不同的对象

观察者模式

行为型模式

意图：定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新

装饰者模式

结构型模式

意图：动态地给一个对象添加一些额外的职责。就增加功能来说，装饰器模式相比生成子类更为灵活

装饰模式主要通过构造方法传入子类对象，IO体系就是使用装饰模式，装饰增强父类的方法而已

装饰者和多态的区别

• 多态是可以强制转换的，而且指向父类的话，只能用父类的方法，不能使用子类独有的
• 装饰者通过构造器传参，多态是动态绑定

装饰者模式和继承的区别

继承实现的增强类：
　　 优点：代码结构清晰，而且实现简单
　　 缺点：对于每一个的需要增强的类都要创建具体的子类来帮助其增强，这样会导致继承体系过于庞大。

装饰模式实现的增强类：
　　 优点：内部可以通过多态技术对多个需要增强的类进行增强
　　 缺点：需要内部通过多态技术维护需要增强的类的实例。进而使得代码稍微复杂。

建造者模式

复杂对象分离创建，创建好组件后组件装配成需要的复杂对象

原型模式

调用原型的clone（）（实现Cloneable接口）来或其他手段来创建对象

浅复制

对目标类的简单复制创建

public object clone(){//重写接口Cloneable的clone()
    return (目标类)super.clone();
}

深复制

对目标类的属性也会进行类型复制创建

public object clone(){//重写接口Cloneable的clone()
    目标类 对象= (目标类)super.clone();
    对象.属性=(属性类型)this.属性.clone();
}

适配器模式

不修改原有代码结构（类结构）友好完成各个系统的对接

• 类适配器模式
• 对象适配器模式
• 接口适配器模式

代理模式

对象和目标对象不适合或不能够直接访问，需要通过一个代理对象来实现访问

正向代理：目标明确（选定指定的那个）

反向代理：目的一致，对象不一定一致

访问者模式

将数据结构和对数据的操作分离开来

中介者模式

第七原则（迪米特法则）的应用，对象和对象之间补直接交互，通过中介者来实现对象间的交互