设计模式--单例模式和工厂模式

最新推荐文章于 2022-12-07 18:40:38 发布
最新推荐文章于 2022-12-07 18:40:38 发布
阅读量73 收藏
点赞数
分类专栏： 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_38705074/article/details/109297945
版权

1、单例模式

1.1

package com.yqj.pattern.singleton.type01;

public class Singleton01 {
    public static void main(String[] args) {
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance == instance2);
    }
}

class Singleton{
    private static final Singleton instance = new Singleton();

    private Singleton() {}

    public static Singleton getInstance(){
        return instance;
    }
}

1.2

package com.yqj.pattern.singleton.type02;

public class Singleton02 {
    public static void main(String[] args) {
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance == instance2);
    }
}

class Singleton {
    private static Singleton instance;

    static {
        instance = new Singleton();
    }

    private Singleton() {}

    public static Singleton getInstance(){
        return instance;
    }
}

1.3

package com.yqj.pattern.singleton.type03;

public class Singleton03 {
    public static void main(String[] args) {
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance == instance2);
    }
}

class Singleton {
    private static Singleton instance;

    private Singleton() {}

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

1.4

package com.yqj.pattern.singleton.type04;

public class Singleton04 {
    public static void main(String[] args) {
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance == instance2);
    }
}

class Singleton{
    private static volatile Singleton instance;

    private Singleton() {}

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

1.5

package com.yqj.pattern.singleton.type05;

public class Singleton05 {
    public static void main(String[] args) {
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance == instance2);
    }
}

class Singleton{
    private static Singleton instance;

    private Singleton() {}

    private static class SingletonInstance{
        private static final Singleton INSTANCE = new Singleton();
    }

    public static Singleton getInstance(){
        return SingletonInstance.INSTANCE;
    }
}

1.6

package com.yqj.pattern.singleton.type06;

public class Singleton06 {
    public static void main(String[] args) {
        Singleton instance = Singleton.INSTANCE;
        Singleton instance2 = Singleton.INSTANCE;
        System.out.println(instance == instance2);
        instance.doSomething();
    }
}

enum Singleton{
    INSTANCE;
    public void doSomething(){
        System.out.println("Hello World");
    }
}

2、工厂模式

2.1简单工厂

package com.yqj.pattern.factory.simpleFactory.improve.order;

import com.yqj.pattern.factory.simpleFactory.improve.pizza.Pizza;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class OrderPizza {
    Pizza pizza = null;
    SimpleFactory factory = null;

    public OrderPizza(SimpleFactory factory){
        setFactory(factory);
    }

    public void setFactory(SimpleFactory factory){
        this.factory = factory;
        String orderType;
        do{
            orderType = getOrderType();
            pizza = this.factory.getFactory(orderType);
            if(pizza != null){
                pizza.prepare();
                pizza.bake();
                pizza.cut();
                pizza.box();
            }else {
                System.out.println("订购披萨失败");
                break;
            }
        }while (true);
    }

    private String getOrderType(){
        try {
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("input pizza type: ");
            String orderType = bufferedReader.readLine();
            return orderType;
        } catch (IOException e) {
            e.printStackTrace();
            return "";
        }
    }

    public static void main(String[] args) {
        new OrderPizza(new SimpleFactory());
    }
}


package com.yqj.pattern.factory.simpleFactory.improve.order;

import com.yqj.pattern.factory.simpleFactory.improve.pizza.CheesePizza;
import com.yqj.pattern.factory.simpleFactory.improve.pizza.GreekPizza;
import com.yqj.pattern.factory.simpleFactory.improve.pizza.Pizza;

public class SimpleFactory {
    public Pizza getFactory(String orderType){
        Pizza pizza = null;
        if("cheese".equals(orderType)){
            pizza = new CheesePizza();
        } else if ("greek".equals(orderType)){
            pizza = new GreekPizza();
        }
        return pizza;
    }
}


package com.yqj.pattern.factory.simpleFactory.improve.pizza;

public class CheesePizza extends Pizza {
    @Override
    public void prepare() {
        setPizzaName("希腊pizza");
        System.out.println(pizzaName+"准备制作");
    }
}


package com.yqj.pattern.factory.simpleFactory.improve.pizza;

public class GreekPizza extends Pizza {

    @Override
    public void prepare() {
        setPizzaName("奶酪pizza");
        System.out.println(pizzaName + "准备制作");
    }
}


package com.yqj.pattern.factory.simpleFactory.improve.pizza;

public abstract class Pizza {
    protected String pizzaName;

    public void setPizzaName(String pizzaName) {
        this.pizzaName = pizzaName;
    }

    public abstract void prepare();

    public void bake() {
        System.out.println(pizzaName + "烘焙披萨");
    }

    public void cut() {
        System.out.println(pizzaName + "切披萨");
    }

    public void box() {
        System.out.println(pizzaName + "打包披萨");
    }


}


package com.yqj.pattern.factory.simpleFactory.staticimprove.order;

import com.yqj.pattern.factory.simpleFactory.staticimprove.pizza.Pizza;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class OrderPizza {
    Pizza pizza = null;

    public OrderPizza(){
        setFactory();
    }

    public void setFactory(){
        String orderType;
        do{
            orderType = getOrderType();
            pizza = SimpleStaticFactory.getFactory(orderType);
            if(pizza != null){
                pizza.prepare();
                pizza.bake();
                pizza.cut();
                pizza.box();
            }else {
                System.out.println("订购披萨失败");
                break;
            }
        }while (true);
    }

    private String getOrderType(){
        try {
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("input pizza type: ");
            String orderType = bufferedReader.readLine();
            return orderType;
        } catch (IOException e) {
            e.printStackTrace();
            return "";
        }
    }

    public static void main(String[] args) {
        new OrderPizza();
    }
}


package com.yqj.pattern.factory.simpleFactory.staticimprove.order;

import com.yqj.pattern.factory.simpleFactory.staticimprove.pizza.CheesePizza;
import com.yqj.pattern.factory.simpleFactory.staticimprove.pizza.GreekPizza;
import com.yqj.pattern.factory.simpleFactory.staticimprove.pizza.Pizza;

public class SimpleStaticFactory {
    public static Pizza getFactory(String orderType){
        Pizza pizza = null;
        if("cheese".equals(orderType)){
            pizza = new CheesePizza();
        } else if ("greek".equals(orderType)){
            pizza = new GreekPizza();
        }
        return pizza;
    }
}


package com.yqj.pattern.factory.simpleFactory.staticimprove.pizza;

public class CheesePizza extends Pizza {
    @Override
    public void prepare() {
        setPizzaName("希腊pizza");
        System.out.println(pizzaName+"准备制作");
    }
}


package com.yqj.pattern.factory.simpleFactory.staticimprove.pizza;

public class GreekPizza extends Pizza {

    @Override
    public void prepare() {
        setPizzaName("奶酪pizza");
        System.out.println(pizzaName + "准备制作");
    }
}


package com.yqj.pattern.factory.simpleFactory.staticimprove.pizza;

public abstract class Pizza {
    protected String pizzaName;

    public void setPizzaName(String pizzaName) {
        this.pizzaName = pizzaName;
    }

    public abstract void prepare();

    public void bake() {
        System.out.println(pizzaName + "烘焙披萨");
    }

    public void cut() {
        System.out.println(pizzaName + "切披萨");
    }

    public void box() {
        System.out.println(pizzaName + "打包披萨");
    }


}


package com.yqj.pattern.factory.simpleFactory.triditional.order;

import com.yqj.pattern.factory.simpleFactory.improve.pizza.CheesePizza;
import com.yqj.pattern.factory.simpleFactory.improve.pizza.GreekPizza;
import com.yqj.pattern.factory.simpleFactory.improve.pizza.Pizza;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class OrderPizza {
    Pizza pizza = null;
    String orderType = null;

    public OrderPizza(){
        do {
            orderType = getOrderType();
            if("cheese".equals(orderType)){
                pizza = new CheesePizza();
            } else if ("greek".equals(orderType)){
                pizza = new GreekPizza();
            } else {
                break;
            }
            pizza.prepare();
            pizza.bake();
            pizza.cut();
            pizza.box();
        } while (true);
    }

    private String getOrderType(){
        try {
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("input pizza type: ");
            String orderType = bufferedReader.readLine();
            return orderType;
        } catch (IOException e) {
            e.printStackTrace();
            return "";
        }
    }

    public static void main(String[] args) {
        new OrderPizza();
    }
}


package com.yqj.pattern.factory.simpleFactory.triditional.pizza;

public class CheesePizza extends Pizza {
    @Override
    public void prepare() {
        setPizzaName("希腊pizza");
        System.out.println(pizzaName+"准备制作");
    }
}


package com.yqj.pattern.factory.simpleFactory.triditional.pizza;

public class GreekPizza extends Pizza {

    @Override
    public void prepare() {
        setPizzaName("奶酪pizza");
        System.out.println(pizzaName + "准备制作");
    }
}


package com.yqj.pattern.factory.simpleFactory.triditional.pizza;

public abstract class Pizza {
    protected String pizzaName;

    public void setPizzaName(String pizzaName) {
        this.pizzaName = pizzaName;
    }

    public abstract void prepare();

    public void bake() {
        System.out.println(pizzaName + "烘焙披萨");
    }

    public void cut() {
        System.out.println(pizzaName + "切披萨");
    }

    public void box() {
        System.out.println(pizzaName + "打包披萨");
    }


}

2.2、工厂方法

package com.yqj.pattern.factory.factorymethod.order;

import com.yqj.pattern.factory.factorymethod.pizza.*;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

class BJOrderPizza extends OrderPizza{

    @Override
    public Pizza createPizza(String orderType) {
        Pizza pizza = null;
        if("cheese".equals(orderType)){
            pizza = new BJCheesePizza();
        } else if("greek".equals(orderType)){
            pizza = new BJGreekPizza();
        }
        return pizza;
    }
}

class LDOrderPizza extends OrderPizza{

    @Override
    public Pizza createPizza(String orderType) {
        Pizza pizza = null;
        if("cheese".equals(orderType)){
            pizza = new LDCheesePizza();
        }else if("greek".equals(orderType)){
            pizza = new LDGreekPizza();
        }
        return pizza;
    }
}

public abstract class OrderPizza {

    public abstract Pizza createPizza(String orderType);

    public OrderPizza(){
        Pizza pizza = null;
        do{
            String orderType = getOrderType();
            pizza = createPizza(orderType);
            if(pizza!=null){
                pizza.prepare();
                pizza.bake();
                pizza.cut();
                pizza.box();
            } else {
                System.out.println("订购失败");
                break;
            }

        }while (true);
    }


    private String getOrderType(){
        try {
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("input pizza type: ");
            String orderType = bufferedReader.readLine();
            return orderType;
        } catch (IOException e) {
            e.printStackTrace();
            return "";
        }
    }

    public static void main(String[] args) {
        new BJOrderPizza();
    }
}


package com.yqj.pattern.factory.factorymethod.order;

import com.yqj.pattern.factory.factorymethod.pizza.*;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

class BJOrderPizza extends OrderPizza{

    @Override
    public Pizza createPizza(String orderType) {
        Pizza pizza = null;
        if("cheese".equals(orderType)){
            pizza = new BJCheesePizza();
        } else if("greek".equals(orderType)){
            pizza = new BJGreekPizza();
        }
        return pizza;
    }
}

class LDOrderPizza extends OrderPizza{

    @Override
    public Pizza createPizza(String orderType) {
        Pizza pizza = null;
        if("cheese".equals(orderType)){
            pizza = new LDCheesePizza();
        }else if("greek".equals(orderType)){
            pizza = new LDGreekPizza();
        }
        return pizza;
    }
}

public abstract class OrderPizza {

    public abstract Pizza createPizza(String orderType);

    public OrderPizza(){
        Pizza pizza = null;
        do{
            String orderType = getOrderType();
            pizza = createPizza(orderType);
            if(pizza!=null){
                pizza.prepare();
                pizza.bake();
                pizza.cut();
                pizza.box();
            } else {
                System.out.println("订购失败");
                break;
            }

        }while (true);
    }


    private String getOrderType(){
        try {
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("input pizza type: ");
            String orderType = bufferedReader.readLine();
            return orderType;
        } catch (IOException e) {
            e.printStackTrace();
            return "";
        }
    }

    public static void main(String[] args) {
        new BJOrderPizza();
    }
}


package com.yqj.pattern.factory.factorymethod.order;

import com.yqj.pattern.factory.factorymethod.pizza.*;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

class BJOrderPizza extends OrderPizza{

    @Override
    public Pizza createPizza(String orderType) {
        Pizza pizza = null;
        if("cheese".equals(orderType)){
            pizza = new BJCheesePizza();
        } else if("greek".equals(orderType)){
            pizza = new BJGreekPizza();
        }
        return pizza;
    }
}

class LDOrderPizza extends OrderPizza{

    @Override
    public Pizza createPizza(String orderType) {
        Pizza pizza = null;
        if("cheese".equals(orderType)){
            pizza = new LDCheesePizza();
        }else if("greek".equals(orderType)){
            pizza = new LDGreekPizza();
        }
        return pizza;
    }
}

public abstract class OrderPizza {

    public abstract Pizza createPizza(String orderType);

    public OrderPizza(){
        Pizza pizza = null;
        do{
            String orderType = getOrderType();
            pizza = createPizza(orderType);
            if(pizza!=null){
                pizza.prepare();
                pizza.bake();
                pizza.cut();
                pizza.box();
            } else {
                System.out.println("订购失败");
                break;
            }

        }while (true);
    }


    private String getOrderType(){
        try {
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("input pizza type: ");
            String orderType = bufferedReader.readLine();
            return orderType;
        } catch (IOException e) {
            e.printStackTrace();
            return "";
        }
    }

    public static void main(String[] args) {
        new BJOrderPizza();
    }
}


package com.yqj.pattern.factory.factorymethod.pizza;

public class BJCheesePizza extends Pizza {
    @Override
    public void prepare() {
        setPizzaName("北京奶酪pizza");
        System.out.println(pizzaName+"准备制作");
    }
}


package com.yqj.pattern.factory.factorymethod.pizza;

public class BJGreekPizza extends Pizza {

    @Override
    public void prepare() {
        setPizzaName("北京希腊pizza");
        System.out.println(pizzaName + "准备制作");
    }
}


package com.yqj.pattern.factory.factorymethod.pizza;

public class LDCheesePizza extends Pizza {

    @Override
    public void prepare() {
        setPizzaName("伦敦奶酪pizza");
        System.out.println(pizzaName + "准备制作");
    }
}

package com.yqj.pattern.factory.factorymethod.pizza;

public class LDGreekPizza extends Pizza {
    @Override
    public void prepare() {
        setPizzaName("伦敦希腊pizza");
        System.out.println(pizzaName + "准备制作");
    }
}


package com.yqj.pattern.factory.factorymethod.pizza;

public abstract class Pizza {
    protected String pizzaName;

    public void setPizzaName(String pizzaName) {
        this.pizzaName = pizzaName;
    }

    public abstract void prepare();

    public void bake() {
        System.out.println(pizzaName + "烘焙披萨");
    }

    public void cut() {
        System.out.println(pizzaName + "切披萨");
    }

    public void box() {
        System.out.println(pizzaName + "打包披萨");
    }


}

2.3、抽象工厂

package com.yqj.pattern.factory.abstractfactory.order;

import com.yqj.pattern.factory.abstractfactory.pizza.Pizza;

public interface AbsFactory {
    Pizza createPizza(String orderType);
}


package com.yqj.pattern.factory.abstractfactory.order;

import com.yqj.pattern.factory.abstractfactory.pizza.BJCheesePizza;
import com.yqj.pattern.factory.abstractfactory.pizza.BJGreekPizza;
import com.yqj.pattern.factory.abstractfactory.pizza.Pizza;

public class BJFactory implements AbsFactory {
    @Override
    public Pizza createPizza(String orderType) {
        Pizza pizza = null;
        if("cheese".equals(orderType)){
            pizza = new BJCheesePizza();
        }else if("greek".equals(orderType)){
            pizza = new BJGreekPizza();
        }
        return pizza;
    }
}


package com.yqj.pattern.factory.abstractfactory.order;


import com.yqj.pattern.factory.abstractfactory.pizza.LDCheesePizza;
import com.yqj.pattern.factory.abstractfactory.pizza.LDGreekPizza;
import com.yqj.pattern.factory.abstractfactory.pizza.Pizza;

public class LDFactory implements AbsFactory {
    @Override
    public Pizza createPizza(String orderType) {
        Pizza pizza = null;
        if("cheese".equals(orderType)){
            pizza = new LDCheesePizza();
        }else if("greek".equals(orderType)){
            pizza = new LDGreekPizza();
        }
        return pizza;
    }
}


package com.yqj.pattern.factory.abstractfactory.order;


import com.yqj.pattern.factory.abstractfactory.pizza.Pizza;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class OrderPizza {
    AbsFactory factory;

    public OrderPizza(AbsFactory factory){
        setFactory(factory);
    }

    public void setFactory(AbsFactory factory){
        this.factory = factory;
        Pizza pizza = null;
        do{
            String orderType = getOrderType();
            pizza = this.factory.createPizza(orderType);
            if(pizza!=null){
                pizza.prepare();
                pizza.bake();
                pizza.cut();
                pizza.box();
            }else {
                System.out.println("订购失败");
                break;
            }
        }while (true);
    }

    private String getOrderType(){
        try {
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("input pizza type: ");
            String orderType = bufferedReader.readLine();
            return orderType;
        } catch (IOException e) {
            e.printStackTrace();
            return "";
        }
    }

    public static void main(String[] args) {
        new OrderPizza(new BJFactory());
    }
}


package com.yqj.pattern.factory.abstractfactory.pizza;

public class BJCheesePizza extends Pizza {
    @Override
    public void prepare() {
        setPizzaName("北京奶酪pizza");
        System.out.println(pizzaName+"准备制作");
    }
}


package com.yqj.pattern.factory.abstractfactory.pizza;

public class BJGreekPizza extends Pizza {

    @Override
    public void prepare() {
        setPizzaName("北京希腊pizza");
        System.out.println(pizzaName + "准备制作");
    }
}


package com.yqj.pattern.factory.abstractfactory.pizza;

public class LDCheesePizza extends Pizza {

    @Override
    public void prepare() {
        setPizzaName("伦敦奶酪pizza");
        System.out.println(pizzaName + "准备制作");
    }
}

package com.yqj.pattern.factory.abstractfactory.pizza;

public class LDGreekPizza extends Pizza {
    @Override
    public void prepare() {
        setPizzaName("伦敦希腊pizza");
        System.out.println(pizzaName + "准备制作");
    }
}


package com.yqj.pattern.factory.abstractfactory.pizza;

public abstract class Pizza {
    protected String pizzaName;

    public void setPizzaName(String pizzaName) {
        this.pizzaName = pizzaName;
    }

    public abstract void prepare();

    public void bake() {
        System.out.println(pizzaName + "烘焙披萨");
    }

    public void cut() {
        System.out.println(pizzaName + "切披萨");
    }

    public void box() {
        System.out.println(pizzaName + "打包披萨");
    }


}
帅哥阿飞
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
设计模式--单例模式 工厂模式
Ysuhang的博客
09-22 225
工厂模式将目的将创建对象的具体过程屏蔽隔离起来，从而达到更高的灵活性，工厂模式可以分为三类：简单工厂模式（Simple Factory）工厂方法模式（Factory Method）抽象工厂模式（Abstract Factory）我们在了解工厂模式时，先从现实生活说起:（1）在没有工厂的时代，如果客户需要一款宝马车，那么就需要客户去创建一款宝马车，然后拿来用。（2）简单工厂模式：后来出现了工厂，用户不再需要去创建宝马车，由工厂进行创建，想要什么车，直接通过工厂创建就可以了。
设计模式-单例-工厂
knight的博客
07-22 135
设计原则 一句话归纳 目的 开闭原则 对扩展开放，对修改关闭 降低维护带来的新风险 依赖倒置原则 高层不应该依赖低层，要面向接口编程 更利于代码结构的升级扩展 单一职责原则 一个类只干一件事，实现类要单一 便于理解，提高代码的可读性 接口隔离原则 一个接口只干一件事，接口要精简单一 功能解耦，高聚合、低耦合 迪米特法则 不该知道的不要知道，一个类应该保持对其它对象最少的了解，降低耦合度 只和朋友交流，不和陌生人说话，减少代码臃肿 里氏替换原则 不要破坏继承体系，子类重写方...
设计模式之单例模式和工厂模式
03-10
细心整合和单例模式和工厂模式的几种模型，懒汉式，饿汉式，如何并发操作模式，等都有详细讲解
Python 入门笔记25——设计模式
学习爱好者fz的博客
04-15 188
Python 入门笔记25——设计模式工厂模式实现单例模式实现 设计模式是面向对象语言特有的内容，是我们在面临某一类问题时候固定的做法，设计模式有很多种，比较流行的是：GOF（Goup Of Four）23 种设计模式。 本文学习两个最常用的模式：工厂模式和单例模式。 工厂模式实现 工厂模式实现了创建者和调用者的分离，使用专门的工厂类将选择实现类、创建对象进行统一的管理和控制。 #测试工厂模式 class CarFactory: def create_car(self,brand):
设计模式：（二）单例与工厂模式
余笙的博客
02-28 1702
一、单例设计模式（Singleton） 1、概述 类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法（静态方法）。 定义：指一个类只有一个实例，且该类能自行创建这个实例的一种模式。 举例：Windows 中只能打开一个任务管理器，这样可以避免因打开多个任务管理器窗口而造成内存资源的浪费，或出现各个窗口显示内容的不一致等错误。还有操作系统中的文件系统、多线程中的线程池、显卡的驱动程序对象、打印机的后台处理服务、应用程序的日志对象、
设计模式：单例模式和工厂模式
Sinder小德的博客
12-07 4337
单例模式与工厂模式的基本原理和实现，以及单例模式结合工厂模式的基本应用。
常见的设计模式【单例模式&工厂模式】
yifei_345678的博客
06-20 881
常见开发模式中单例模式、工厂模式的相关介绍
设计模式源代码--工厂模式与单例
09-19
本资源主要关注两种经典的设计模式：工厂模式和单例模式。这两种模式在实际编程中非常常见，尤其对于提高代码的可扩展性和可维护性至关重要。 ### 工厂模式 工厂模式是一种创建型设计模式，它提供了一种创建对象的...
一例读懂设计模式-单例模式、简单工厂模式.zip
08-31
本资源“一例读懂设计模式-单例模式、简单工厂模式.zip”旨在帮助初学者通过实例深入理解这两种重要设计模式：单例模式和简单工厂模式。以下是关于这两个模式的详细讲解。 1. **单例模式**： 单例模式是一种限制类...
设计模式的工厂模式，单例模式
03-14
在给定的标题和描述中，我们关注的是两种重要的设计模式：工厂模式和单例模式。 **工厂模式**是一种创建型设计模式，它提供了一种创建对象的最佳方式。在工厂模式中，当客户端需要创建一个对象时，而不是直接创建，...
Python的设计模型-----工厂模式和单例模式
偷得浮生半日闲
10-16 650
设计模式是面向对象语言特有的内容，使我们在面临某一类问题时固定的做法，设计模式有很多种，比较流行的是：GOF（Goup Of Four）23种设计模式。我们没有必要全学，学习几个常用的的即可 我们最常用的模式：工厂模式和单例模式（只要在复杂的场景在会使用） 工厂模式 工厂模式实现了创建者和调用者的分离，使用专门的工厂类将选择实现类、创建对象进行统一的管理和控制。 【例子】 # 工厂模式 ''' 一般情况下我们要创建一个工厂类（创造我们想创造...
Java设计模式详解 ------ 工厂+单例
weixin_44083609的博客
11-28 281
工厂+单例，单独的工厂太简单了= =实在提不起兴趣写，那就写个通用的单例工厂工具类吧，代码如下↓ package test.designpatterns; import entity.User; public class FactoryAndSimple { //工厂加单例，完全体，直接传什么进来都能用。 //接收的工具 private static Object ob...
常见的设计模式(单例模式&工厂模式)
m0_65725031的博客
06-22 1578
用于产生对象的方法或者式类，称之为工厂。 上面所讲到的单例模式也可以看作为一个特殊的工厂。为什么需要工作模式，原来使用new的方式感觉也很简单，且好懂？使用工厂的原因是我们可以通过工厂模式，来集中控制对象的创建过程，这样可以给设计带来更多的灵活性。比如：spring的IOC容器就是工厂模式的经典实现。今天的学习到此结束啦！！！...
设计模式一（工厂模式、抽象工厂模式、单例模式）
wangxiaai的博客
01-17 3908
本文从总结的角度去学习23种设计模式去掉不应有的废话。适合复习阅读和部分初学者。
java中的设计模式之单例模式、工厂模式
IT菜鸟报道的博客
07-03 327
Java中的设计模式            转载地址：https://www.toutiao.com/i6573486403282272775/为什么要学习设计模式1）设计模式都是一些相对优秀的解决方案，很多问题都是典型的、有代表性的问题，学习设计模式，我们就不用自己从头来解决这些问题，相当于在巨人的肩膀上，复用这些方案即可。2）设计模式已经成为专业人士的常用词汇，不懂不利于交流。3）能让你设计的...
决策概率论，一文读懂群体决策概率与个体决策概率的关系
最新发布
09-04
有一本书叫做《乌合之众》把群体批得一无是处，然而另一本书《群体的智慧》又阐述群体是有智慧的，群体越大，智慧越高。 读了这篇决策概率论的文章，让你对于群体和个体不再迷茫。
Java项目-基于微信小程序的微信点餐系统（包括源码，数据库，教程）.zip
09-04
Java毕设，小程序毕业设计，小程序课程设计，含有代码注释，新手也可看懂。毕业设计、期末大作业、课程设计、高分必看，下载下来，简单部署，就可以使用。 包含：项目源码、数据库脚本、软件工具等，该项目可以作为毕设、课程设计使用，前后端代码都在里面。 该系统功能完善、界面美观、操作简单、功能齐全、管理便捷，具有很高的实际应用价值。 项目都经过严格调试，确保可以运行！可以放心下载 1. 技术组成 前端： 小程序 后台框架：SSM/SpringBoot（如果有的话） 开发环境：idea，微信开发者工具 数据库：MySql（建议用 5.7 版本，8.0 有时候会有坑） 数据库可视化工具：使用 Navicat 部署环境：Tomcat（建议用 7.x 或者 8.x 版本），maven
Java项目-基于微信小程序的springboot基于微信小程序的学生宿舍管理系统（包括源码，数据库，教程）.zip
09-04
Java毕设，小程序毕业设计，小程序课程设计，含有代码注释，新手也可看懂。毕业设计、期末大作业、课程设计、高分必看，下载下来，简单部署，就可以使用。 包含：项目源码、数据库脚本、软件工具等，该项目可以作为毕设、课程设计使用，前后端代码都在里面。 该系统功能完善、界面美观、操作简单、功能齐全、管理便捷，具有很高的实际应用价值。 项目都经过严格调试，确保可以运行！可以放心下载 1. 技术组成 前端： 小程序 后台框架：SSM/SpringBoot（如果有的话） 开发环境：idea，微信开发者工具 数据库：MySql（建议用 5.7 版本，8.0 有时候会有坑） 数据库可视化工具：使用 Navicat 部署环境：Tomcat（建议用 7.x 或者 8.x 版本），maven
设计模式解析：单例模式与简单工厂模式
本文主要介绍了创建型和结构型设计模式的相关知识，重点讲解了单例模式的实现方式以及简单工厂模式的优势。 创建型设计模式主要关注对象的创建，旨在控制对象的实例化过程，确保在系统中只有一个实例或按特定方式...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值