设计模式23种之工厂模式（内附代码）

最新推荐文章于 2023-03-04 21:27:39 发布
置顶 最新推荐文章于 2023-03-04 21:27:39 发布
阅读量388 收藏 1
点赞数
文章标签： 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Liaryank/article/details/114396782
版权

工厂模式个人理解总结：

定义一个创建产品对象的工厂接口，将产品对象的实际创建工作推迟到具体子工厂类当中。这满足创建型模式中所要求的“创建与使用相分离”的特点。

工厂模式包括三种：

  1. 简单工厂模式又叫作静态工厂方法模式
  2. 工厂方法模式
  3. 抽象工厂模式

优点和缺点：

优点：

  1. 工厂类包含必要的逻辑判断，可以决定在什么时候创建哪一个产品的实例。客户端可以免除直接创建产品对象的职责，很方便的创建出相应的产品。工厂和产品的职责区分明确。
  2. 客户端无需知道所创建具体产品的类名，只需知道参数即可。
  3. 也可以引入配置文件，在不修改客户端代码的情况下更换和添加新的具体产品类。

缺点：

  1. 简单工厂模式的工厂类单一，负责所有产品的创建，职责过重，一旦异常，整个系统将受影响。且工厂类代码会非常臃肿，违背高聚合原则。
  2. 使用简单工厂模式会增加系统中类的个数（引入新的工厂类），增加系统的复杂度和理解难度
  3. 系统扩展困难，一旦增加新产品不得不修改工厂逻辑，在产品类型较多时，可能造成逻辑过于复杂
  4. 简单工厂模式使用了 static 工厂方法，造成工厂角色无法形成基于继承的等级结构。

模式的结构与实现

简单工厂模式的主要角色如下：

  • 简单工厂：是简单工厂模式的核心，负责实现创建所有实例的内部逻辑。工厂类的创建产品类的方法可以被外界直接调用，创建所需的产品对象。
  • 抽象产品：是简单工厂创建的所有对象的父类，负责描述所有实例共有的公共接口。
  • 具体产品：是简单工厂模式的创建目标。
/**
 * @Title: design
 * @Description:简单工厂模式
 * @author: liaryank
 * @Date: 2021/3/5 4:59 下午
 * @Version: 1.0
 */
public class SimpleFactory {
    public static void main(String[] args) {
        Product product = SimpleFactory1.makeProduct(1);
        product.show();
    }
    //抽象产品
    public interface Product {
        void show();
    }
    //具体产品：ProductA
    static class ConcreteProduct1 implements Product {
        public void show() {
            System.out.println("产品1展示...");
        }
    }
    //具体产品：ProductB
    static class ConcreteProduct2 implements Product {
        public void show() {
            System.out.println("产品2展示...");
        }
    }
    final class Const {
        static final int PRODUCT_A = 0;
        static final int PRODUCT_B = 1;
    }
    static class SimpleFactory1 {
        public static Product makeProduct(int kind) {
            switch (kind) {
                case Const.PRODUCT_A:
                    return new ConcreteProduct1();
                case Const.PRODUCT_B:
                    return new ConcreteProduct2();
            }
            return null;
        }
    }
}

 工厂方法模式的主要角色如下：

优点：

  • 用户只需要知道具体工厂的名称就可得到所要的产品，无须知道产品的具体创建过程。
  • 灵活性增强，对于新产品的创建，只需多写一个相应的工厂类。
  • 典型的解耦框架。高层模块只需要知道产品的抽象类，无须关心其他实现类，满足迪米特法则、依赖倒置原则和里氏替换原则。

缺点：

  • 类的个数容易过多，增加复杂度
  • 增加了系统的抽象性和理解难度
  • 抽象产品只能生产一种产品，此弊端可使用抽象工厂模式解决。

应用场景：

  • 客户只知道创建产品的工厂名，而不知道具体的产品名。如三星手机工厂、华为手机工厂等。
  • 创建对象的任务由多个具体子工厂中的某一个完成，而抽象工厂只提供创建产品的接口。
  • 客户不关心创建产品的细节，只关心产品的品牌

模式的结构与实现：

工厂方法模式由抽象工厂、具体工厂、抽象产品和具体产品等4个要素构成。本节来分析其基本结构和实现方法。

工厂方法模式的主要角色如下：

  1. 抽象工厂：提供了创建产品的接口，调用者通过它访问具体工厂的工厂方法 newProduct() 来创建产品。
  2. 具体工厂：主要是实现抽象工厂中的抽象方法，完成具体产品的创建。
  3. 抽象产品：定义了产品的规范，描述了产品的主要特性和功能。
  4. 具体产品：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间一一对应。
package com.designpattern.design.pattern;

/**
 * @Title: design
 * @Description: 工厂方法模式
 * @author: liaryank
 * @Date: 2021/3/7 10:37 上午
 * @Version: 1.0
 */
public class AbstractFactoryX {
    public static void main(String[] args) {
        try {
            Product a;
            AbstractFactory af;
            af = (AbstractFactory) ReadXML.getObject();
            a = af.newProduct();
            a.show();
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }
}

//抽象产品：提供了产品的接口
interface Product {
    public void show();
}

//具体产品1：实现抽象产品中的抽象方法
class ConcreteProduct1 implements Product {
    public void show() {
        System.out.println("产品1内容显示...");
    }
}

//具体产品2：实现抽象产品中的抽象方法
class ConcreteProduct2 implements Product {
    public void show() {
        System.out.println("产品2内容显示...");
    }
}

//抽象工厂：提供了厂品的生成方法
interface AbstractFactory {
    public Product newProduct();
}

//具体工厂1：实现了厂品的生成方法
class ConcreteFactory1 implements AbstractFactory {
    public Product newProduct() {
        System.out.println("工厂1生成-->具体产品1...");
        return new ConcreteProduct1();
    }
}

//具体工厂2：实现了厂品的生成方法
class ConcreteFactory2 implements AbstractFactory {
    public Product newProduct() {
        System.out.println("工厂2生成-->具体产品2...");
        return new ConcreteProduct2();
    }

}

 

package com.designpattern.design.pattern;

import org.w3c.dom.*;

import javax.xml.parsers.*;
import java.io.File;

/**
 * @Title: design
 * @Description:
 * @author: liaryank
 * @Date: 2021/3/7 10:41 上午
 * @Version: 1.0
 */
public class ReadXML {
    //从XML配置文件中提取具体类类名，并返回一个实例对象
    public static Object getObject() {
        try {
            //创建文档对象
            DocumentBuilderFactory dFactory = DocumentBuilderFactory.newInstance();
            DocumentBuilder builder = dFactory.newDocumentBuilder();
            Document doc;
            //本地文件路径
            doc = builder.parse(new File("/Users/Downloads/config1.xml"));
            //获取包含类名的文本节点
            NodeList nl = doc.getElementsByTagName("className");
            Node classNode = nl.item(0).getFirstChild();
            String ClassName = "com.designpattern.design.pattern." + classNode.getNodeValue();
            //通过类名生成实例对象并将其返回
            Class<?> c = Class.forName(ClassName);
            Object obj = c.newInstance();
            return obj;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<config>
	<className>ConcreteFactory2</className>
</config>

搞一个真实场景 ，用工厂方法模式设计畜牧场：

 

package com.designpattern.design.pattern;

import javax.swing.*;
import java.awt.*;

/**
 * @Title: design
 * @Description: 工厂方法模式
 * @author: liaryank
 * @Date: 2021/3/7 11:05 上午
 * @Version: 1.0
 */
public class AnimalFarmX {
    public static void main(String[] args) {
        try {
            Animal a;
            AnimalFarm af;
            af = (AnimalFarm) ReadXML1.getObject();
            a = af.newAnimal();
            a.show();
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }
}
//抽象产品：动物类
interface Animal {
    public void show();
}
//具体产品：猪类
class Horse implements Animal {
    JScrollPane sp;
    JFrame jf = new JFrame("工厂方法模式测试");
    public Horse() {
        Container contentPane = jf.getContentPane();
        JPanel p1 = new JPanel();
        p1.setLayout(new GridLayout(1, 1));
        p1.setBorder(BorderFactory.createTitledBorder("动物：猪"));
        sp = new JScrollPane(p1);
        contentPane.add(sp, BorderLayout.CENTER);
        JLabel l1 = new JLabel(new ImageIcon("/Users/liaryank/Downloads/e.jpeg"));
        p1.add(l1);
        jf.pack();
        jf.setVisible(false);
        jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);    //用户点击窗口关闭
    }
    public void show() {
        jf.setVisible(true);
    }
}
//具体产品：牛类
class Cattle implements Animal {
    JScrollPane sp;
    JFrame jf = new JFrame("工厂方法模式测试");
    public Cattle() {
        Container contentPane = jf.getContentPane();
        JPanel p1 = new JPanel();
        p1.setLayout(new GridLayout(1, 1));
        p1.setBorder(BorderFactory.createTitledBorder("动物：牛"));
        sp = new JScrollPane(p1);
        contentPane.add(sp, BorderLayout.CENTER);
        JLabel l1 = new JLabel(new ImageIcon("/Users/liaryank/Downloads/b.png"));
        p1.add(l1);
        jf.pack();
        jf.setVisible(false);
        jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);    //用户点击窗口关闭
    }
    public void show() {
        jf.setVisible(true);
    }
}
//抽象工厂：畜牧场
interface AnimalFarm {
    public Animal newAnimal();
}
//具体工厂：养猪场
class Pig implements AnimalFarm {
    public Animal newAnimal() {
        System.out.println("新猪出生！");
        return new Horse();
    }
}
//具体工厂：养牛场
class CattleFarm implements AnimalFarm {
    public Animal newAnimal() {
        System.out.println("新牛出生！");
        return new Cattle();
    }
}

package com.designpattern.design.pattern;

import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import java.io.File;

/**
 * @Title: design
 * @Description: 工厂方法模式使用
 * @author: liaryank
 * @Date: 2021/3/7 11:05 上午
 * @Version: 1.0
 */
public class ReadXML1 {
    public static Object getObject() {
        try {
            DocumentBuilderFactory dFactory = DocumentBuilderFactory.newInstance();
            DocumentBuilder builder = dFactory.newDocumentBuilder();
            Document doc;
            doc = builder.parse(new File("/Users/liaryank/Downloads/3-1Q114140526/config2.xml"));
            NodeList nl = doc.getElementsByTagName("className");
            Node classNode = nl.item(0).getFirstChild();
            String className = "com.designpattern.design.pattern." + classNode.getNodeValue();
            Class<?> c = Class.forName(className);
            Object obj = c.newInstance();
            return obj;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
}

 

<?xml version="1.0" encoding="UTF-8"?>
<config>
	<className>Pig</className>
</config>

运行效果图

抽象工厂（AbstractFactory）模式的定义与特点：

是一种为访问类提供一个创建一组相关或相互依赖对象的接口，且访问类无须指定所要产品的具体类就能得到同族的不同等级的产品的模式结构。

模式的结构与实现

抽象工厂模式同工厂方法模式一样，也是由抽象工厂、具体工厂、抽象产品和具体产品等 4 个要素构成，但抽象工厂中方法个数不同，抽象产品的个数也不同。现在我们来分析其基本结构和实现方法。

抽象工厂模式的主要角色如下：

  1. 抽象工厂（Abstract Factory）：提供了创建产品的接口，它包含多个创建产品的方法 newProduct()，可以创建多个不同等级的产品。
  2. 具体工厂（Concrete Factory）：主要是实现抽象工厂中的多个抽象方法，完成具体产品的创建。
  3. 抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能，抽象工厂模式有多个抽象产品。
  4. 具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间是多对一的关系。

 

package com.designpattern.design.pattern;
import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

import java.awt.*;
import java.io.File;
import javax.swing.*;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;

/**
 * @Title: design
 * @Description: 抽象工厂模式
 * @author: liaryank
 * @Date: 2021/3/7 11:36 上午
 * @Version: 1.0
 */
public class FarmX {
    public static void main(String[] args) {
        try {
            Farm f;
            Animal a;
            Plant p;
            f = (Farm) ReadXML2.getObject();
            a = f.newAnimal();
            p = f.newPlant();
            a.show();
            p.show();
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }
}
//抽象产品：动物类
interface Animal {
    public void show();
}
//具体产品：马类
class Horse implements Animal {
    JScrollPane sp;
    JFrame jf = new JFrame("抽象工厂模式测试");
    public Horse() {
        Container contentPane = jf.getContentPane();
        JPanel p1 = new JPanel();
        p1.setLayout(new GridLayout(1, 1));
        p1.setBorder(BorderFactory.createTitledBorder("动物：马"));
        sp = new JScrollPane(p1);
        contentPane.add(sp, BorderLayout.CENTER);
        JLabel l1 = new JLabel(new ImageIcon("/Users/liaryank/Downloads/e.jpeg"));
        p1.add(l1);
        jf.pack();
        jf.setVisible(false);
        jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//用户点击窗口关闭
    }
    public void show() {
        jf.setVisible(true);
    }
}
//具体产品：牛类
class Cattle implements Animal {
    JScrollPane sp;
    JFrame jf = new JFrame("抽象工厂模式测试");
    public Cattle() {
        Container contentPane = jf.getContentPane();
        JPanel p1 = new JPanel();
        p1.setLayout(new GridLayout(1, 1));
        p1.setBorder(BorderFactory.createTitledBorder("动物：牛"));
        sp = new JScrollPane(p1);
        contentPane.add(sp, BorderLayout.CENTER);
        JLabel l1 = new JLabel(new ImageIcon("/Users/liaryank/Downloads/b.png"));
        p1.add(l1);
        jf.pack();
        jf.setVisible(false);
        jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//用户点击窗口关闭
    }
    public void show() {
        jf.setVisible(true);
    }
}
//抽象产品：植物类
interface Plant {
    public void show();
}
//具体产品：水果类
class Fruitage implements Plant {
    JScrollPane sp;
    JFrame jf = new JFrame("抽象工厂模式测试");
    public Fruitage() {
        Container contentPane = jf.getContentPane();
        JPanel p1 = new JPanel();
        p1.setLayout(new GridLayout(1, 1));
        p1.setBorder(BorderFactory.createTitledBorder("植物：水果"));
        sp = new JScrollPane(p1);
        contentPane.add(sp, BorderLayout.CENTER);
        JLabel l1 = new JLabel(new ImageIcon("src/P_Fruitage.jpg"));
        p1.add(l1);
        jf.pack();
        jf.setVisible(false);
        jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//用户点击窗口关闭
    }
    public void show() {
        jf.setVisible(true);
    }
}
//具体产品：蔬菜类
class Vegetables implements Plant {
    JScrollPane sp;
    JFrame jf = new JFrame("抽象工厂模式测试");
    public Vegetables() {
        Container contentPane = jf.getContentPane();
        JPanel p1 = new JPanel();
        p1.setLayout(new GridLayout(1, 1));
        p1.setBorder(BorderFactory.createTitledBorder("植物：蔬菜"));
        sp = new JScrollPane(p1);
        contentPane.add(sp, BorderLayout.CENTER);
        JLabel l1 = new JLabel(new ImageIcon("src/P_Vegetables.jpg"));
        p1.add(l1);
        jf.pack();
        jf.setVisible(false);
        jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//用户点击窗口关闭
    }
    public void show() {
        jf.setVisible(true);
    }
}
//抽象工厂：农场类
interface Farm {
    public Animal newAnimal();
    public Plant newPlant();
}
//具体工厂：韶关农场类
class SGfarm implements Farm {
    public Animal newAnimal() {
        System.out.println("新牛出生！");
        return new Cattle();
    }
    public Plant newPlant() {
        System.out.println("蔬菜长成！");
        return new Vegetables();
    }
}
//具体工厂：上饶农场类
class SRfarm implements Farm {
    public Animal newAnimal() {
        System.out.println("新马出生！");
        return new Horse();
    }
    public Plant newPlant() {
        System.out.println("水果长成！");
        return new Fruitage();
    }
}


class ReadXML2 {
    public static Object getObject() {
        try {
            DocumentBuilderFactory dFactory = DocumentBuilderFactory.newInstance();
            DocumentBuilder builder = dFactory.newDocumentBuilder();
            Document doc;
            doc = builder.parse(new File("/Users/liaryank/Downloads/config.xml"));
            NodeList nl = doc.getElementsByTagName("className");
            Node classNode = nl.item(0).getFirstChild();
            String cName = "com.designpattern.design.pattern." + classNode.getNodeValue();
            System.out.println("新类名：" + cName);
            Class<?> c = Class.forName(cName);
            Object obj = c.newInstance();
            return obj;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<config>
	<className>SGfarm</className>
</config>

运行效果图

Liaryank
关注
三大工厂设计模式应用总结
STAR
05-05 2159
一.题目分析 1.题目一：简单工厂模式的应用 （1）题目要求：模拟女娲造人；传入参数M，返回一个Man对象，传入参数W，返回一个Woman对象；在此实现基础上，增加一个机器人类，传入参数R，返回一个Robot对象；实现该题目要求，并且观察女娲的变化。 （2）题目应用知识点：运用简单工厂模式编程实现 2.题目二：工厂方法模式的应用 （1）题目要求：模拟不同工厂生产空调；海尔工厂生产海尔空调，美的工厂...
设计模式的应用（简单工厂、工厂方法、抽象工厂）
qq_43165874的博客
05-11 305
一．实验目的 熟悉建模工具。 掌握简单工厂模式、工厂方法模式、抽象工厂模式，并进行设计应用。 二、实验内容 (1)、 简单工厂模式 使用简单工厂模式模拟女娲（Nvwa）造人（Person），如果传入参数M，则返回一个Man对象，如果传入参数W，则返回一个Woman对象，请实现该场景。现需要增加一个新的Robot类，如果传入参数R，则返回一个Robot对象，对代码进行修改并注意女娲的变化。 (2...
设计模式-简单工厂模式及应用
fw19940314的博客
03-03 220
目录简单工厂模式角色代码案例优缺点应用场景简单工厂模式的典型应用及源码分析 简单工厂模式  工厂模式的定义：定义一个创建产品对象的工厂接口，将产品对象的实际创建工作推迟到具体子工厂类当中。这满足创建型模式中所要求的“创建与使用相分离”的特点。 按实际业务场景划分，工厂模式有 3 种不同的实现方式，分别是简单工厂模式、工厂方法模式和抽象工厂模式。下面将陆续讲解几种设计模式。 简单工厂模式(Simple Factory Pattern)：定义一个工厂类，它可以根据参数的不同返回不同类的实例，被创建的实
使用工厂设计模式的场景
JamesZhao1987的专栏
01-12 315
创建类对象虽然可以使用new(底层也是通过反射创建对象的),但是在一些情况下使用工厂模式确实最合适的。 情况一：如果一个对象拥有很多子类，那么创建该对象的子类使用工厂模式是最合适的，不但可以面向接口的编程，为维护以及开发带来方便。 情况二：如果创建某个对象时需要进行许多额外的操作，如查询数据库然后将查询到的值赋予要创建的对象(单例初始化时使用比较多),或是需要许多额外的赋值等等。如果查看JDK...
设计模式之工厂模式详解和应用
赵广陆
02-13 1090
目录 1 工厂模式的历史由来 2.简单工厂模式 2.1 简单工厂模式定义 2.2 简单工厂模式案例 2.3 简单工厂模式相关源码 2.4 简单工厂模式优缺点 3 工厂方法模式 3.1 工厂方法模式定义 3.2 工厂方法模式案例 3.3 工厂方法模式源码 3.4 工厂方法模式优缺点 4 抽象工厂模式 4.1 抽象工厂模式定义 4.2 抽象工厂模式案例 4.3 抽象工厂模式优缺点 5 简单工厂 vs 工厂方法 vs 抽象工厂
c#代码介绍23种设计模式-02简单工厂模式(附代码)
09-21
该原则就是——封装改变，既然要封装改变，自然也就要找到改变的代码，然后把改变的代码用类来封装，这样的一种思路也就是我们简单工厂模式的实现方式 在外面打工的人，免不了要经常在外面吃饭，当然我们也可以自己...
c#代码介绍23种设计模式-04抽象工厂模式(附代码)
最新发布
09-21
因为现在的工厂都多元化了，一个工厂创建一系列的产品，如果我们要设计这样的系统时，工厂方法模式显然在这里不适用，然后抽象工厂模式却可以很好地解决一系列产品创建的问题, 2. 抽象工厂模式实例 以生活中 “绝味...
c#代码介绍23种设计模式-03工厂模式(附代码)
09-21
这样工厂方法模式就可以允许系统不修改工厂类逻辑的情况下来添加新产品，这样也就克服了简单工厂模式中缺点 2. 使用工厂方法实现的系统，如果系统需要添加新产品时： 我们可以利用多态性来完成系统的扩展，对于抽象...
设计模式精解-GoF-23种设计模式解析--附C++源代码
02-18
这本书详细阐述了23种设计模式，这些模式被广泛应用于各种编程语言，包括C++。 1. **创建型模式**：这类模式主要关注对象的创建过程，它们提供了一种在不指定具体类的情况下创建对象的方法，使得系统更加灵活和可...
23种设计模式之工厂模式代码示例.txt
03-08
23种设计模式
工厂模式代码
08-30
工厂模式代码
工厂方法设计模式 代码片
qq_40406491的博客
09-17 208
/** 工厂设计模式 * 定义接口 */ public interface PlantCarService { void getCar(); void getBUgCar(); } 创建两个实现类 分别时间这个接口 public class PlantBusImpl implements PlantCarService { @Override public ...
23种设计模式-工厂模式（安卓应用场景介绍）
qq_19764133的博客
03-04 2830
工厂模式是一种创建型设计模式，它提供了一种创建对象的方式，而无需将具体的对象创建逻辑暴露给客户端。在Java中，工厂模式常常用于创建复杂对象或对象的构造过程涉及到多个步骤的情况。
设计模式之工厂模式——应用最广泛的模式
qianhaifeng2012的博客
07-24 1812
工厂模式主要分为三种，简单工厂模式、工厂方法模式、抽象工厂模式。 1、绪论 在面向对象编程中, 最通常的方法是一个new操作符产生一个对象实例,new操作符就是用来构造对象实例的。但是在一些情况下, new操作符直接生成对象会带来一些问题。举例来说, 许多类型对象的创造需要一系列的步骤: 你可能需要计算或取得对象的初始设置; 选择生成哪个子对象实例; 或在生成你需要的对象之前必须先生成一些辅助
【设计模式】Java 工厂模式与应用
Fxtack的博客
08-07 340
Java 简单工厂模式 精讲 摘要 本文通过对静态工厂进行简单的介绍。并介绍与实现其与其他两种设计模式——单例模式与享元模式，的组合实现，以达到特定的功能实现。 文章目录Java 简单工厂模式 精讲摘要一. 简单工厂模式简介二. 简单工厂模式三. 静态工厂模式 + 单例模式四. 静态工厂模式 + 享元模式总结 [1]优点缺点参考文献 一. 简单工厂模式简介 简单工厂模式是在面向对象编程中一种常用的设计模式。该设计模式 “重塑” 了对象的创建过程，使得能够对象的创建、控制、管理得到了便利。 但请注意，简
设计模式-工厂的代码实现与详解
weixin_43845524的博客
08-13 339
设计模式-工厂的代码实现与详解
设计模式 | 用实际案例详解工厂模式
小白菜的博客
06-06 1380
我们来看一个具体需求 看一个披萨的项目，要便于披萨种类的扩展，要便于维护，有以下要求： 披萨的种类很多（比如GreekPizz、CheesePizz等） 披萨的制作有prepare，bake，cut，box 完成披萨店订购功能 首先我们先编写一个Pizza抽象类： package com.cxc.factory.simplefactory.pizzastore.pizza; /** * 抽...
设计模式之工厂模式（附代码示例）
DreamsArchitects的博客
12-02 892
快速了解设计模式，让你的业务代码更加的简介、优雅。
Java设计模式：23种之工厂模式详解及代码示例
简单工厂模式，虽然不是GOF(设计模式之父)提出的23种标准设计模式之一，但常被用作工厂方法模式的特殊情况。它定义了一个创建产品对象的静态方法，隐藏了其实现细节。如文中所示，通过`SimpleFactory.createProduct...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值