常用设计模式之单例模式、策略模式、工厂模式

小狗爱世界2024-10-02 7:07

单例模式

单例模式属于创建型模式

饿汉模式：立即加载

java 复制代码 
public class Singleton {  
    private static Singleton instance = new Singleton();  
    private Singleton (){
    }  
    public static Singleton getInstance() {  
        return instance;  
    }  
}

懒汉模式，懒加载

  • 线程不安全

    java 复制代码 
    public class Singleton {
    private static Singleton instance;
    private Singleton (){
    }
    public static Singleton getlnstance() {
        if (instance == null){
            instance = new Singleton();
        }
         return instance;
    }
}

  • 线程安全

    java 复制代码 
    public class Singleton {  
    private static Singleton instance;  
    private Singleton (){}  
    public static synchronized Singleton getInstance() {  
        if (instance == null) {  
            instance = new Singleton();  
        }  
        return instance;  
    }  
}

  • 双重锁

    java 复制代码 
    public class Singleton {  
    private volatile static Singleton singleton;  
    private Singleton (){
    }  
    public static Singleton getSingleton() {  
        if (singleton == null) {  
            synchronized (Singleton.class) {  
                if (singleton == null) {  
                    singleton = new Singleton();  
                }  
            }  
        }  
        return singleton;  
    }  
}

  • 静态内部类

    java 复制代码 
    public class Singleton {
    private Singleton() {
    }
    
    //内部类在外部类调用的时候才会被初始化
    // 内部类一定要在方法调用之前初始化
    private static class SingletonInstance {
        private static final Singleton instance = new Singleton();
    }
    
    // static 使单例空间共享
    // final使得方法不能被重写重载
    public static final Singleton getInstance() {
        return SingletonInstance.instance;
    }
}

策略模式

策略模式属于行为型模式

核心思想是对算法进行封装，委派给不同对象来管理。

比如我们旅游可以选择出行的策略有：自行车、电动车、公交车等-

  • 结构

    策略模式饱汉三种类：

    角色 关系 作用
    抽象策略类strategy 是所有类的父类 定义一个公共接口，定义一些算法标识和抽象方法
    具体策略concrete strategy 是抽象策略的接口实现类 实现抽象策略定义的抽象方法，描述具体法的算法实现
    环境context 维护一个抽象策略类的引用实例 委托策略变量，调用具体策略所实现的抽象策略接口中的方法

工厂模式

概念

工厂模式，提供一种创建对象的方式，

在创建对象时提供一种封装机制，将实际创建对象的代码与使用代码分离

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

不暴露对象创建逻辑的情况下创建对象，

主要解决接口选择问题

角色

抽象产品：产品的共同接口或抽象类

具体产品：实现了抽象产品接口

抽象工厂：声明创建产品的抽象方法

具体工厂实现抽象工厂接口

分类

分为：简单工厂、方法工厂、抽象工厂

实现

  • 简单工厂
java 复制代码 
//简单工厂：每创建一个产品就会增加一个对应的具体的工厂类
// 违背了开闭原则，不属于23种GOF
public class Test {
    public static void main(String[] args) {
        Baozi baozi = SimpleFactory.createBaozi("jiangrou");
        System.out.println(baozi.createBaozi());
        Baozi baozi1 = SimpleFactory.createBaozi("jiangrou");
        System.out.println(baozi1.createBaozi());
    }
}
​
//抽象工厂
interface Baozi {
    String createBaozi();
}
​
//产品的具体的实现
class JiangRou implements Baozi {
    @Override
    public String createBaozi() {
        return "酱肉";
    }
}
​
class XianRou implements Baozi {
    @Override
    public String createBaozi() {
        return "鲜肉";
    }
}
​
//工厂类是关键
//判断要做什么包子，整个做包子的生产都被这个工厂类封装起来了
//用户不需要关注这里面的细节
//适合创建对象比较少的情况，只需传递具体参数，忽略生产细节
class SimpleFactory {
    public static Baozi createBaozi(String type) {
        switch (type) {
            case "jiangrou":
                return new JiangRou();
            case "xianrou":
                return new XianRou();
        }
        return null;
    }
}
  • 方法工厂
java 复制代码 
//工厂方法：定义一个用于创建产品的接口，由子类决定生产什么产品
//如果还有其他类型的包子，需要在SimpleFactory里面加判断，因为只能在那里生产包子，违反开闭原则
//是简单工厂的的抽象，抽象一个工厂接口，
//增加新产品时，需要增加新的工厂
//一个工厂只生产一种产品
public class Test {
    public IPhone getPhoneGrete(String type){
        if ("huawei".equals(type)){
            HuaWeiPhoneFactory huaWeiPhoneFactory = new HuaWeiPhoneFactory();
            IPhone phone = huaWeiPhoneFactory.createPhone();
            return phone;
        }
        if ("xiaomi".equals(type)){
            XiaomiPhoneFactory xiaomiPhoneFactory = new XiaomiPhoneFactory();
            IPhone phone = xiaomiPhoneFactory.createPhone();
            return phone;
        }
        return null;
    }
    public IPC getPcCreate(String type){
        if ("huawei".equals(type)){
            HuaWeiPCFactory huaWeiPCFactory = new HuaWeiPCFactory();
            IPC pc = huaWeiPCFactory.createPC();
            return pc;
        }
        if ("xiaomi".equals(type)){
            XiaomiPCFactory xiaomiPCFactory = new XiaomiPCFactory();
            IPC pc = xiaomiPCFactory.createPC();
            return pc;
        }
        return null;
    }

    public static void main(String[] args) {
        Test test = new Test();
        IPC huawei = test.getPcCreate("huawei");
        IPC xiaomi = test.getPcCreate("xiaomi");
        IPhone xiaomi1 = test.getPhoneGrete("xiaomi");

    }
}
//抽象产品
interface IPhone {
    void createPhone();
}
interface IPC {
    void createPC();
}
interface ISW {
    void createSW();
}
//具体的产品
class HuaWeiPhone implements IPhone {
    @Override
    public void createPhone() {

    }
}
class XiaoMiPhone implements IPhone {
    @Override
    public void createPhone() {
    }
}
class HuaWeiPC implements IPC {
    @Override
    public void createPC() {

    }
}
class XiaoMiPC implements IPC {
    @Override
    public void createPC() {
    }
}

//手机工厂
interface PhoneAbstractFactory {
    IPhone createPhone();
}
//电脑工厂
interface PCAbstractFactory {
    IPC createPC();
}
//华为手机工厂
class HuaWeiPhoneFactory implements PhoneAbstractFactory {
    @Override
    public IPhone createPhone() {
        return new HuaWeiPhone();
    }
}
//华为电脑工厂
class HuaWeiPCFactory implements PCAbstractFactory {

    @Override
    public IPC createPC() {
        return new HuaWeiPC();
    }
}
//小米手机工厂
class XiaomiPhoneFactory implements PhoneAbstractFactory {


    @Override
    public IPhone createPhone() {
        return new XiaoMiPhone();
    }
}
//小米电脑工厂
class XiaomiPCFactory implements PCAbstractFactory {

    @Override
    public IPC createPC() {
        return new XiaoMiPC();
    }
}
  • 抽象工厂
java 复制代码 
//一个工厂可以生产不同产品等级的产品族
public class Test  {
    public static void main(String[] args) {
        HuaweiFactory huaweiFactory = new HuaweiFactory();
        huaweiFactory.createPhone();
        huaweiFactory.createPC();
        XiaomiFactory xiaomiFactory = new XiaomiFactory();
        xiaomiFactory.createPhone();
        xiaomiFactory.createPC();
    }
}

//抽象产品族
interface Phone {
    void createPhone();
}

interface PC {
    void createPC();
}

interface SWI {
    void createSWI();
}

//具体产品族
class XiaoMiPhone implements Phone {
    @Override
    public void createPhone() {
        System.out.println("小米手机");
    }
}
class XiaoMiSWI implements SWI {
    @Override
    public void createSWI() {
        System.out.println("小米手表");
    }
}

class HuaweiPhone implements Phone {
    @Override
    public void createPhone() {
        System.out.println("华为手机");
    }
}

class XiaoPC implements PC {
    @Override
    public void createPC() {
        System.out.println("小米电脑");
    }
}

class HuaweiPC implements PC {
    @Override
    public void createPC() {
        System.out.println("华为电脑");
    }
}


//抽象工厂，一个工厂可以生产不同产品等级的产品族
abstract class AbstractFactory {
    public abstract Phone createPhone();
    public abstract PC createPC();
    public abstract SWI ccreateSWI();
}

//具体工厂
class HuaweiFactory extends AbstractFactory {
    @Override
    public Phone createPhone() {
        return new HuaweiPhone();
    }

    @Override
    public PC createPC() {
        return new HuaweiPC();
    }

    @Override
    public SWI ccreateSWI() {
        return null;
    }
}
class XiaomiFactory extends AbstractFactory {


    @Override
    public Phone createPhone() {
        return new XiaoMiPhone();
    }

    @Override
    public PC createPC() {
        return new XiaoPC();
    }

    @Override
    public SWI ccreateSWI() {
        return new XiaoMiSWI();
    }
}

对比

简单工厂

  • 优点

    • 屏蔽产品的具体实现，调用者只关心产品的接口

  • 缺点

    • 增加产品，需要修改工厂类，违反了开闭原则

    • 工厂类集中了所有的实例的创建逻辑，违反高内聚责任分配原则

工厂方法

  • 优点

    • 继承简单工厂的优点，符合开闭原则

  • 缺点

    • 增加产品时，需要增加工厂类

抽象工厂

  • 优点

    • 不需要知道什么产品被创建

    • 可以通过具体的工厂创建多个对象，增加新的具体工厂和产品族方便

  • 缺点

    • 增加新的产品等级就比较复杂，需要修改抽象工厂和所有的具体工厂类
相关推荐
晨米酱13 小时前
JavaScript 中"对象即函数"设计模式
前端·设计模式
数据智能老司机18 小时前
精通 Python 设计模式——分布式系统模式
python·设计模式·架构
数据智能老司机19 小时前
精通 Python 设计模式——并发与异步模式
python·设计模式·编程语言
数据智能老司机19 小时前
精通 Python 设计模式——测试模式
python·设计模式·架构
数据智能老司机19 小时前
精通 Python 设计模式——性能模式
python·设计模式·架构
使一颗心免于哀伤20 小时前
《设计模式之禅》笔记摘录 - 21.状态模式
笔记·设计模式
数据智能老司机2 天前
精通 Python 设计模式——创建型设计模式
python·设计模式·架构
数据智能老司机2 天前
精通 Python 设计模式——SOLID 原则
python·设计模式·架构
烛阴2 天前
【TS 设计模式完全指南】懒加载、缓存与权限控制：代理模式在 TypeScript 中的三大妙用
javascript·设计模式·typescript
李广坤2 天前
工厂模式
设计模式
热门推荐
01GitHub 镜像站点02UV 工具安装与国内镜像源配置指南0346个Nano-banana 精选提示词，持续更新中04Claude Code 平替：OpenAI发布 Codex CLI ，GPT-5 国内直接使用05UV安装并设置国内源06保姆级教程：手把手教你用Dify实现完美多轮对话（附Chatflow和提示词）07A股预测还能更准？开源大模型Kronos带你跑通预测+回测全流程08Spec-Kit 使用指南09解决 WSL Ubuntu 中 /etc/resolv.conf 自动重置问题10KGG转MP3工具|非KGM文件|解密音频