设计模式

设计模式

概述

GOF23(23种设计模式)

设计模式(Design Pattern)是前辈们对代码开发经验的总结,是解决特定问题的一系列套路.不是语法规定,而是一套用以提高代码可复用性,可维护性,可读性,稳健性以及安全性的解决方案

设计模式的本质是面向对象设计原则的实际运用,是对类的封装性,继承性和多态性以及类的关联关系和组合关系的充分理解

设计模式的基本要素

• 模式名称
• 问题
• 解决方案
• 效果

分类

• 创建型模式:
  • 单例模式,工厂模型,抽象工厂模式,建造者模式,原型模型
• 结构型模式
  • 适配器模式,桥接模式,装饰模式,组合模式,外观模式,享元模式,代理模式
• 行为型模式
  • 模板方法模式,命令模式,迭代器模式,观察者模式,中介者模式,备忘录模式,解释器模式,状态模式,策略模式,职责链模式,访问者模式

面向对象的七大原则

• 开闭原则:对扩展开放,对修改关闭
• 里氏替换原则:继承必须确保超类所拥有的性质在子类中仍然成立(注意is和has的区别)
• 依赖倒置原则:要面向接口编程,不要面向实现编程(实现可能会变,接口比较稳定,容易扩展)
• 单一职责原则:控制类的粒度大小,将对象解耦,提高内聚性(一个方法最好实现一个功能,"‘各司其职’,提高独立性,方便代码复用)
• 接口隔离原则:要为各个类建立它们需要的专用接口(与上面类似,但这里特指接口约束)
• 迪米特法则:只与你的直接朋友交谈,不跟陌生人说话
• 合成复用原则:尽量先使用组合或者聚合关联关系来实现,其次才考虑使用继承关系来实现(is和has的区别)

单例模式

这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。

这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

• 名称:单例模式
• 问题:一个全局使用的类频繁地创建和销毁
• 解决:保证一个类仅有一个实例,并提供一个访问它的全局访问点
• 效果:控制实例数目,节省系统资源
• 关键:构造函数私有化
• 优点:
  • 在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例
  • 避免对资源的多重占用
• 缺点:
  • 没有接口，不能继承，与单一职责原则冲突

创建方式

饿汉式单例

//饿汉式单例,加载一切有的资源
public class Hungry {

    //浪费空间
    private byte[] data1 = new byte[1024*1024*10];

    //创建 Hungry 的一个对象(唯一的实例化)
    private static Hungry instance = new Hungry();

    //构造器私有,无法从外部实例化(关键)
    private Hungry() {
    }

    //向外界提供唯一的获得唯一实例化的入口(
    public static Hungry getInstance(){
        return instance;
    }

    //测试方法
    public void say(){
        System.out.println("hello");
    }
}
//测试类

class test{
    public static void main(String[] args) {
        //Hungry hungry = new Hungry();//这里报错,因为构造器私有化,无法被外部实例化
        //利用Hungry提供的入口获得唯一的实例化
        Hungry instance = Hungry.getInstance();
        instance.say();
    }
}

懒汉式单例

线程不安全–普通懒汉式单例

public class Lazy {

    private static Lazy instance;

    private Lazy() {
        System.out.println(Thread.currentThread().getName());
    }

    public static Lazy getInstance() {
        //加一层判断
        if (instance == null){
            instance = new Lazy();
        }
        return instance;
    }
}

//线程安全测试
class Test{
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                Lazy.getInstance();
            }).start();
        }
    }
}

//结果,线程不安全
Thread-2
Thread-0
Thread-1
Thread-3

线程安全---->双重检测锁的懒汉式单例(DCL 懒汉式单例)

public class Lazy {

    private static Lazy instance;

    private Lazy() {
        System.out.println(Thread.currentThread().getName());
    }

    public static Lazy getInstance() {
        //加一层判断
        if (instance == null){
            //在加一层
            synchronized (Lazy.class){
                if (instance==null) {
                    instance = new Lazy();
                }
            }
        }
        return instance;
    }
}
//线程安全测试
class Test{
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                Lazy.getInstance();
            }).start();
        }
    }
}

但仍存在问题,由于instance = new Lazy();不是原子性操作

1.分配内存空间

2.执行构造方法,初始化对象

3.将该对象指向内存空间

可能出现指令重排现象(1-2-3->1-3-2)

在双重检测锁基础上,避免指令重排

public class Lazy {

    private volatile static Lazy instance;//加上原子性操作

    private Lazy() {
        System.out.println(Thread.currentThread().getName());
    }

    public static Lazy getInstance() {
        //加一层判断
        if (instance == null){
            //在加一层
            synchronized (Lazy.class){
                if (instance==null) {
                    instance = new Lazy();
                }
            }
        }
        return instance;
    }
}
//线程安全测试
class Test{
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                Lazy.getInstance();
            }).start();
        }
    }
}

使用静态内部类创建懒汉式单例

public class Holder(){
    private Holder{
        
    }
    public static Holder getInstance(){
        return InnerClass.instance;
    }
    pulic static class InnerClass{
        private static Holder instance = new Holder();
    }
}

利用反射可以破解单例模式

反射可以无视私有构造器,从而通过反射创建对象

public class Lazy {

    private volatile static Lazy instance;

    private Lazy() {
    }

    public static Lazy getInstance() {
        //加一层判断
        if (instance == null){
            //在加一层
            synchronized (Lazy.class){
                if (instance==null) {
                    instance = new Lazy();
                }
            }
        }
        return instance;
    }
}
class Test{
    public static void main(String[] args) throws Exception {
        Lazy instance = Lazy.getInstance();
        Constructor<Lazy> declaredConstructor = Lazy.class.getDeclaredConstructor();
        declaredConstructor.setAccessible(true);
        Lazy instance2 = declaredConstructor.newInstance();
        System.out.println(instance.equals(instance2));//false ,破坏了单例模式,实例出两个对象
    }
}

使用枚举创建懒汉式单例

这是实现单例模式的最佳方法。它更简洁，自动支持序列化机制，绝对防止多次实例化。

反射无法破坏枚举(没有无参构造,有两个参数的有参构造)

public enum EnumSingle{
    INSTANCE;
    public EnumSingle getInstance(){
        return INSTANCE
    }
}

工厂模式

作用:实现了创建者和调用者的分离

核心本质:

• 实例化对象不使用new,用工厂方法代替
• 将选择实现类,创建对象统一管理和控制,从而将调用者跟我们的实现类解耦

分类

• 简单工厂模式
• 工厂方法模式
• 抽象工厂模式

简单工厂模式

示例

传统

定义一个Car接口

public interface Car {
    void name();
}

实现类:

public class Benz implements Car {
    @Override
    public void name() {
        System.out.println("奔驰");
    }
}

public class Lamborghini implements Car {
    @Override
    public void name() {
        System.out.println("兰博基尼");
    }
}

传统调用

 //传统写法,要知道接口以及实现类
Lamborghini lamborghini = new Lamborghini();
Benz benz = new Benz();
lamborghini.name();
benz.name();

简单工厂模式

新增CarFactory接口,用字符串参数判断实例化对象

//静态工厂模式(简单工厂模式)
//违反开闭原则,新增Car的实现就要改逻辑(修改)
public class CarFactory {
    public static Car getCar(String car){
        if (car.equals("Lamb")){
            return new Lamborghini();
        }else if (car.equals("Benz")){
            return new Benz();
        }else {
            return null;
        }
    }
}

调用

//简单工厂模式
CarFactory carFactory = new CarFactory();
carFactory.getCar("Benz").name();
carFactory.getCar("Lamb").name();

工厂方法模式

不违法开闭原则----但增加了代码量和结构的复杂程度

在Car接口约束的基础上再加一个CarFactory接口约束

CarFactory.java

//工厂方法模式
public interface CarFactory {
    Car getCar();
}

根据实现类的数量创建对应工厂

BenzFactory.java

public class BenzFactory implements CarFactory{
    @Override
    public Car getCar() {
        return new Benz();
    }
}

Lamborghini.java

public class LamborginiFactory implements CarFactory{
    @Override
    public Car getCar() {
        return new Lamborghini();
    }
}

调用

 //工厂方法模式
new BenzFactory().getCar().name();
new LamborginiFactory().getCar().name();

项目结构对比