工厂模式

最新推荐文章于 2025-05-31 10:47:41 发布
最新推荐文章于 2025-05-31 10:47:41 发布
阅读量165 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 软件设计模式 文章标签： 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/codedancing/article/details/103212778

定义

工厂模式（Factory Method）是由一个工厂对象决定创建出哪一种产品类的实例。工厂类来封装实例化对象的行为，将产品的 “实现” 和 “使用” 解耦。

工厂模式有三类：简单工厂模式、工厂方法模式、 抽象工厂模式。

工厂模式属于类创建型模式，抽象工厂模式属于对象创建型模式。

 

要点

抽象工厂（Abstract Factory）：提供创建产品的接口，调用者通过它访问具体工厂的实现方法来创建产品。
具体工厂（ConcreteFactory）：实现抽象工厂中的抽象方法来完成具体产品的创建。
抽象产品（Product）：定义产品规范，描述产品主要特性和功能。
具体产品（ConcreteProduct）：抽象产品的特定需求来实现，由具体工厂来创建，它同具体工厂之间一一对应。

 

场景

当使用 new 实例化一个具体类时，代码绑着具体类会让代码更脆弱，缺乏弹性。在软件开发中，当我们会用到大量的创建某种、某类或者某批对象时，就会使用到工厂模式。

例如有披萨店，客户从 店铺点餐台（OrderPizza） 下单想要的披萨：

Pizza orderPizza(String pizzaType) {
	Pizza pizza;
	if(pizzaType.equals("Pepper")) {
		pizza = new PepperPizza();
	} else if (pizzaType.equals("Greek")) {
		pizza = new GreekPizza();
	} else if (pizzaType.equals("Cheese")) {
		pizza = new CheesePizza();
	}
	pizza.prepare();
	pizza.bake();
	pizza.cut();
	pizza.box();
	return pizza;
}

但是需求发生变化时，例如店铺上架、下架一些 Pizza ，就必须重新打开这段代码进行检查和修改，已经违反了开闭原则，而且点餐台不应该考虑披萨的制作，应该交给 后厨（披萨工厂，Factory） 负责处理。

 

实现

这里主要用代码来演示，可以在Github的链接中获取源码。

1. 简单工厂模式

简单工厂模式是由 一个工厂对象决定创建出哪一种产品类的实例 。简单工厂模式不是一个设计模式，而是一种编程习惯。

if(pizzaType.equals("Pepper")) {
	pizza = new PepperPizza();
} else if (pizzaType.equals("Greek")) {
	pizza = new GreekPizza();
} else if (pizzaType.equals("Cheese")) {
	pizza = new CheesePizza();
}

我们需要把上面的部分代码抽离出来搬到另一个对象中，这个新对象只需要负责创建 Pizza，这个新对象就是 “工厂”，OrderPizza 只需要关心从工厂得到一个披萨就行：

public class SimplePizzaFactory {

	public Pizza createPizza(String pizzaType) {
		Pizza pizza;
		switch (pizzaType) {
            case "Pepper":
                pizza = new PepperPizza();
                pizza.setPizzaName("胡椒风味披萨");
                return pizza;
            case "Greek":
                pizza = new GreekPizza();
                pizza.setPizzaName("希腊风味披萨");
                return pizza;
            case "Cheese":
                pizza = new CheesePizza();
                pizza.setPizzaName("芝士风味披萨");
                return pizza;
            default:
                return null;
        }
	}
	
}

 

示例

需求：披萨项目，需要方便披萨种类的扩展，便于维护，定义一个可以实例化 Pizaa 对象的类，封装创建对象的代码。
1)披萨的种类很多(比如 GreekPizz、CheesePizz 等)
2)披萨的制作有 prepare，bake, cut, box
3)完成披萨店订购功能。

披萨类（抽象）

/**
 * Pizza 抽象类
 */
public abstract class Pizza {

    /**
     * 披萨类型
     */
    protected String pizzaType;

    /**
     * 准备原材料, 不同的披萨不一样，做成抽象方法
     */
    public abstract void prepare();

    /**
     * 烘烤
     */
    public void bake() {
        System.out.println(pizzaType + "baking...");
    }

    /**
     * 切块
     */
    public void cut() {
        System.out.println(pizzaType + "cutting...");
    }

    /**
     * 包装
     */
    public void box() {
        System.out.println(pizzaType + "boxing...");
    }

    public void setPizzaType(String pizzaType) {
        this.pizzaType = pizzaType;
    }

}

胡椒风味披萨

/**
 * 胡椒风味披萨
 */
public class PepperPizza extends Pizza {

    @Override
    public void prepare() {
        System.out.println("给胡椒风味披萨准备原材料");
    }

}

希腊风味披萨

/**
 * 希腊风味披萨
 */
public class GreekPizza extends Pizza {

    @Override
    public void prepare() {
        System.out.println("给希腊风味披萨准备原材料");
    }

}

芝士风味披萨

/**
 * 芝士风味披萨
 */
public class CheesePizza extends Pizza {

    @Override
    public void prepare() {
        System.out.println("给芝士风味披萨准备原材料");
    }

}

简单工厂类

/**
 * 简单披萨工厂类
 */
public class SimplePizzaFactory {

    public Pizza createPizza(String pizzaType) {
        Pizza pizza;
        switch (pizzaType) {
            case "PepperPizza":
                pizza = new PepperPizza();
                pizza.setPizzaType("胡椒风味披萨");
                return pizza;
            case "GreekPizza":
                pizza = new GreekPizza();
                pizza.setPizzaType("希腊风味披萨");
                return pizza;
            case "CheesePizza":
                pizza = new CheesePizza();
                pizza.setPizzaType("芝士风味披萨");
                return pizza;
            default:
                return null;
        }
    }

}

披萨商店

/**
 * 披萨商店
 */
public class PizzaStore {

    private static final BufferedReader READER = new BufferedReader(new InputStreamReader(System.in));

    /**
     * 给披萨商店供货的披萨工厂（ 后厨 ）
     */
    private SimplePizzaFactory factory;

    public PizzaStore(SimplePizzaFactory factory) {
        this.factory = factory;
    }

    /**
     * 披萨制作流程
     */
    public void orderPizza() {
        String pizzaType;
        Pizza pizza;
        do {
            pizzaType = getType();
            // 使用简单工厂创建实例，解耦！解耦！解耦！
            pizza = this.factory.createPizza(pizzaType);

            if (pizza != null) {
                pizza.prepare();
                pizza.bake();
                pizza.cut();
                pizza.box();
            } else {
                System.out.println("披萨暂时缺货！请重新订购。");
            }
        } while (true);
    }

    /**
     * 获取客户订购的披萨种类
     *
     * @return 披萨类型
     */
    private static String getType() {
        System.out.println("\n请输入披萨类型：");
        try {
            return READER.readLine();
        } catch (IOException e) {
            e.printStackTrace();
            return "";
        }
    }

}

这里的工厂，将对象实例化抽离出来，解耦。

源代码

Click here

 

2. 工厂方法模式

工厂方法模式定义了一个创建产品对象的接口，需要子类决定需要实例化的类是哪一个。工厂方法模式将对象的实例化推迟到子类。

在这里插入图片描述

示例

新需求：
有了加盟披萨店，根据加盟店地域的饮食口味不同，每家加盟店可以提供地域特色的披萨，比如 北京风味的胡椒披萨、伦敦风味的胡椒披萨。

分析：
如果使用简单工厂模式创建不同的简单工厂类，比如 BJPizzaSimpleFactory、LDPizzaSimpleFactory 等等，那么每家工厂都有了各自的制作流程，这是不行的，必须符合总店的制作流程规范才行，然后，这些加盟店可以自由地制作符合该区域特色风味的披萨。

将披萨的制作流程做成抽象方法，在不同的披萨工厂中具体实现。

北京胡椒风味披萨

/**
 * 北京胡椒风味披萨
 */
public class BJPepperPizza extends Pizza {

    @Override
    public void prepare() {
        System.out.println("给北京胡椒风味披萨准备原材料");
    }

}

伦敦胡椒风味披萨

/**
 * 伦敦胡椒风味披萨
 */
public class LDPepperPizza extends Pizza {

    @Override
    public void prepare() {
        System.out.println("给伦敦胡椒风味披萨准备原材料");
    }

}

披萨商店（抽象）

/**
 * 披萨商店（抽象）
 */
public abstract class AbstractPizzaStore {

    private static final BufferedReader READER = new BufferedReader(new InputStreamReader(System.in));

    /**
     * 定义抽象方法createPizza, 让各个工厂子类自己实现当地的特色风味披萨
     */
    protected abstract Pizza createPizza(String pizzaType);

    /**
     * 披萨制作流程，所有的加盟店都需要遵守
     */
    protected final void orderPizza() {
        String pizzaType;
        Pizza pizza;
        do {
            pizzaType = getType();
            // 顾客决定工厂，子类工厂决定披萨，解耦！解耦！解耦！
            pizza = createPizza(pizzaType);

            if (pizza != null) {
                pizza.prepare();
                pizza.bake();
                pizza.cut();
                pizza.box();
            } else {
                System.out.println("披萨暂时缺货！请重新订购。");
            }
        } while (true);
    }

    /**
     * 获取客户订购的披萨种类
     *
     * @return 披萨类型
     */
    private String getType() {
        System.out.println("\n请输入披萨类型：");
        try {
            return READER.readLine();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return "";
    }
}

北京披萨商店

/**
 * 北京披萨商店
 */
public class BJPizzaStore extends AbstractPizzaStore {

    @Override
    public Pizza createPizza(String pizzaType) {
        Pizza pizza;
        switch (pizzaType) {
            case "PepperPizza":
                pizza = new BJPepperPizza();
                pizza.setPizzaType("北京胡椒风味披萨");
                return pizza;
            case "GreekPizza":
                pizza = new BJGreekPizza();
                pizza.setPizzaType("北京希腊风味披萨");
                return pizza;
            case "CheesePizza":
                pizza = new BJCheesePizza();
                pizza.setPizzaType("北京芝士风味披萨");
                return pizza;
            default:
                return null;
        }
    }

}

伦敦披萨商店

/**
 * 伦敦披萨商店
 */
public class LDPizzaStore extends AbstractPizzaStore {

    @Override
    public Pizza createPizza(String pizzaType) {
        Pizza pizza;
        switch (pizzaType) {
            case "PepperPizza":
                pizza = new LDPepperPizza();
                pizza.setPizzaType("伦敦胡椒风味披萨");
                return pizza;
            case "GreekPizza":
                pizza = new LDGreekPizza();
                pizza.setPizzaType("伦敦希腊风味披萨");
                return pizza;
            case "CheesePizza":
                pizza = new LDCheesePizza();
                pizza.setPizzaType("伦敦芝士风味披萨");
                return pizza;
            default:
                return null;
        }
    }

}

这里的工厂生产一种产品，那就是披萨。

源代码

Click here

 

3. 抽象工厂模式

抽象工厂模式提供一个接口，用于创建相关或依赖对象的家族，而无需指明具体的类。

抽象工厂允许客户使用抽象的接口来创建一组相关的产品，而不需要知道（或关心）实际产出的具体产品是什么，客户就从具体的产品中被解耦。

在这里插入图片描述

示例

需求：
工厂模式让所有加盟店使用总店的制作流程规范，为了防止加盟店使用廉价的食材增加利润，这可能会损害品牌形象，我们需要建立一家原料工厂来防止这样的事情发生。但是，不同地域的食材可能是不一样的。

这次的工厂面向的是披萨原料。

酱料

/**
 * 酱料类型
 */
public interface Sauce {

    /**
     * 获取酱料类型名
     */
    String getSauceType();

}

/**
 * 面团类型
 */
public interface Dough {

    /**
     * 获取面团类型名
     */
    String getDoughType();

}

/**
 * 芝士类型
 */
public interface Cheese {

    /**
     * 获取芝士类型名
     */
    String getCheeseType();

}

披萨（抽象）

/**
 * 披萨（抽象）
 */
public abstract class AbstractPizza {

    /**
     * 披萨类型
     */
    protected String pizzaType;
    /**
     * 披萨的酱料
     */
    protected Sauce sauce;
    /**
     * 披萨的面团
     */
    protected Dough dough;
    /**
     * 披萨的芝士
     */
    protected Cheese cheese;

    /**
     * 基本的做法（具体种类的披萨去实现）
     */
    public abstract void prepare();

    /**
     * 烘烤
     */
    public void bake() {
        System.out.println( pizzaType + "baking...");
    }

    /**
     * 切块
     */
    public void cut() {
        System.out.println(pizzaType + "cutting...");
    }

    /**
     * 包装
     */
    public void box() {
        System.out.println(pizzaType + "boxing...");
    }

    public void setPizzaType(String pizzaType) {
        this.pizzaType = pizzaType;
    }

}

北京风味的芝士披萨

/**
 * 北京风味的芝士披萨
 */
public class BJCheesePizza extends AbstractPizza {

    private PizzaIngredientFactory ingredientFactory;

    public BJCheesePizza(PizzaIngredientFactory ingredientFactory) {
        this.ingredientFactory = ingredientFactory;
    }

    @Override
    public void prepare() {
        System.out.println(pizzaType + " preparing...");
        sauce = ingredientFactory.createSauce();
        System.out.println("sauce: " + sauce.getSauceType());
        dough = ingredientFactory.createDough();
        System.out.println("dough: " + dough.getDoughType());
        cheese = ingredientFactory.createCheese();
        System.out.println("cheese: " + cheese.getCheeseType() + "\n");
    }

}

伦敦风味的芝士披萨

/**
 * 伦敦风味的芝士披萨
 */
public class LDCheesePizza extends AbstractPizza {

    private PizzaIngredientFactory ingredientFactory;

    public LDCheesePizza(PizzaIngredientFactory ingredientFactory) {
        this.ingredientFactory = ingredientFactory;
    }

    @Override
    public void prepare() {
        System.out.println(pizzaType + " preparing...");
        sauce = ingredientFactory.createSauce();
        System.out.println("sauce: " + sauce.getSauceType());
        dough = ingredientFactory.createDough();
        System.out.println("dough: " + dough.getDoughType());
        cheese = ingredientFactory.createCheese();
        System.out.println("cheese: " + cheese.getCheeseType() + "\n");
    }
}

披萨商店（抽象）

/**
 * 披萨商店（抽象）
 */
public abstract class AbstractPizzaStore {

    private static final BufferedReader READER = new BufferedReader(new InputStreamReader(System.in));

    /**
     * 让子类自己实现
     */
    protected abstract AbstractPizza createPizza(String pizzaType);

    /**
     * 披萨制作流程
     */
    protected final void orderPizza() {
        String pizzaType;
        AbstractPizza pizza;
        do {
            pizzaType = getType();
            pizza = createPizza(pizzaType);

            if (pizza != null) {
                pizza.prepare();
                pizza.bake();
                pizza.cut();
                pizza.box();
            } else {
                System.out.println("披萨暂时缺货！请重新订购。");
            }
        } while (true);
    }

    /**
     * 获取客户订购的披萨种类
     *
     * @return 披萨类型
     */
    private String getType() {
        System.out.println("\n请输入披萨类型：");
        try {
            return READER.readLine();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return "";
    }
}

伦敦披萨商店

/**
 * 伦敦披萨商店
 */
public class BJPizzaStore extends AbstractPizzaStore {

    private PizzaIngredientFactory ingredientFactory = new BJPizzaIngredientFactory();

    @Override
    protected AbstractPizza createPizza(String pizzaType) {
        AbstractPizza pizza;

        switch (pizzaType) {
            case "CheesePizza":
                pizza = new BJCheesePizza(ingredientFactory);
                pizza.setPizzaType("北京芝士风味披萨");
                return pizza;
            default:
                return null;
        }
    }

}

伦敦披萨商店

/**
 * 伦敦披萨商店
 */
public class LDPizzaStore extends AbstractPizzaStore {

    private PizzaIngredientFactory ingredientFactory = new LDPizzaIngredientFactory();

    @Override
    protected AbstractPizza createPizza(String pizzaType) {
        AbstractPizza pizza;

        switch (pizzaType) {
            case "CheesePizza":
                pizza = new LDCheesePizza(ingredientFactory);
                pizza.setPizzaType("伦敦风味披萨");
                return pizza;
            default:
                return null;
        }
    }

}

食材工厂定义接口（抽象工厂）

/**
 * 为食材工厂定义接口
 */
public interface PizzaIngredientFactory {

    /**
     * 面团
     */
    Dough createDough();

    /**
     * 酱料
     */
    Sauce createSauce();

    /**
     * 芝士
     */
    Cheese createCheese();

}

北京披萨食材工厂

/**
 * 北京披萨食材工厂
 */
public class BJPizzaIngredientFactory implements PizzaIngredientFactory {

    @Override
    public Sauce createSauce() {
        return new MarinaraSauce();
    }

    @Override
    public Dough createDough() {
        return new ThinCrustDough();
    }

    @Override
    public Cheese createCheese() {
        return new ReggianoCheese();
    }

}

伦敦披萨食材工厂

/**
 * 伦敦披萨食材工厂
 */
public class LDPizzaIngredientFactory implements PizzaIngredientFactory {

    @Override
    public Sauce createSauce() {
        return new PlumTomatoSauce();
    }

    @Override
    public Dough createDough() {
        return new ThickCrustDough();
    }

    @Override
    public Cheese createCheese() {
        return new MozzarellaCheese();
    }

}

这里的食材工厂可以生产多种食材，而不是一种食材。

源代码

Click here

 

总结

使用工厂模式的好处在于面向接口编程，它可以将产品的 “使用” 和 “生产” 解耦，将创建对象的代码集中在一个地方，可以避免代码中的重复，方便后期维护。工厂模式很好地结合了 依赖倒置原则（要依赖抽象，不要依赖具体） ，想要遵循依赖倒置原则，工厂方法是很好的技巧。

  • 所有的工厂都是用来封装对象的创建。
  • 所有工厂模式都通过减少应用程序和具体类之间的依赖实现松耦合。
  • 工厂方法模式使用继承形式，对象的创建延迟到子类进行。
  • 工厂方法模式创建一类产品，子类实现工厂方法来创建对象。
  • 抽象工厂模式使用对象组合形式，对象的创建被实现在工厂接口所暴露出来的方法中。
  • 抽象工厂模式创建相关的产品家族，而不需要依赖它们的具体类。

举例：在JDK的 Calender 日期类中就使用工厂模式来创建不同的日期实例类。

工厂模式和策略模式区别
小白的大数据之旅的博客
08-22 1051
在深入对比工厂模式和策略模式之前，明确研究方法和内容框架至关重要。本文综合采用理论分析与案例分析相结合的研究手段，旨在全面剖析这两种设计模式。理论分析构成了本文研究的基础。通过详细梳理工厂模式和策略模式的定义、分类及特点，本文为后续对比分析提供了坚实的理论支撑。工厂模式，作为一种创建型设计模式，关注于对象的创建过程，通过封装具体的创建逻辑，使得系统无需关注对象是如何被创建和组装的。它分为简单工厂模式、工厂方法模式和抽象工厂模式，每种模式都有其独特的应用场景和优势[5]。
设计模式的七大原则及其分类
xcosy
11-19 998
什么是设计模式？ 设计模式（Design Pattern） ，这个术语最初并不是出现在软件设计中，而是被用于建筑领域的设计中，后来随着软件工程的发展，设计模式思想被引入到软件工程中。直到今天，狭义的设计模式还是人们广为流传的 23 种经典设计模式。 设计模式（Design pattern）代表了计算机软件工程最佳的实践，是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设...
工厂方法模式和抽象工厂模式之间的区别
tekkenvs11的专栏
03-05 570
    工厂方法模式属于对象创建型模式，它定义一个用户创建对象的接口，让子类决定实例化哪一个类。工厂方法模式使一个类的实例化延迟到其子类。 具体来说，就是一个一个抽象产品类，派生出多个具体产品类；同时，一个抽象工厂类，派生出多个具体工厂类。而每个具体工厂类只能创建一个具体产品类的实例。 抽象工厂模式也属于对象创建型模式，它提供了一个创建一系列相关或相互依赖对象的接口，而无须制定它们具体的类...
Design Patterns - Factory Method
qq_34921856的博客
12-10 648
Factory Method(工厂方法) — 对象创建型模式 定义一个用于创建对象的接口，让子类决定实例化哪一个类。Factory Method 使一个类的实例化延迟到其子类(抽象工厂模式中就使用到了工厂方法) 适用场景 当一个类不知道它所必须创建的对象的类的时候 当一个类希望由它的子类来指定它所创建的对象的时候 优点 工厂方法不再将与特定应用有关的类绑定到你的代码中。代码仅处理 Product 接口，因此它可以与用户定义的任何 COncreteProduct 类一起使用。 缺点 创建一个特定的
工厂模式和抽象工厂模式
chenduwei的博客
04-13 2066
工厂模式定义了一个创建对象的接口，但由子类来确定要实例化哪个类。工厂方法让类把实例化推迟到子类；抽象工厂模式提供一个接口来创建相关或依赖对象的家族，而不需要指定具体类
单例模式和工厂模式
qq_54469537的博客
08-04 1543
这篇博客主要介绍了工厂模式以及单例模式中的两种常见模式：饿汉和懒汉模式
工厂模式与抽象工厂模式
webeyebody的博客
04-17 1445
复杂系统中可结合两者，例如用抽象工厂管理核心产品族，工厂模式处理辅助对象。：通过一个工厂接口或类创建单一类型的对象，隐藏具体实现类的实例化逻辑。：当系统只需创建单一类型对象，且未来扩展可能性较低时（如工具类库）。：同一应用在不同操作系统下需生成适配的窗口、按钮等组件（如网页5的。：产品类型过多时，工厂类条件分支会臃肿（如网页2的。：确保产品族的兼容性和一致性。：新增产品类型需修改所有工厂类（如网页4中新增。：单一工厂类根据参数返回不同产品（如网页2的。：新增产品族只需新增具体工厂（如网页5中增加。
Java 工厂模式详解
最新发布
m0_73941339的博客
05-31 1338
在软件开发中，对象的创建是一个基本操作。但直接在代码中使用 关键字创建对象会导致代码耦合度高、可维护性差。工厂模式（Factory Pattern）作为一种创建型设计模式，能有效解决这些问题。本文将深入探讨 Java 中的工厂模式，通过实例展示其实现方式、优势及适用场景。工厂模式的核心思想是：将对象的创建和使用分离，把对象创建逻辑封装在一个工厂类中，从而提高代码的可维护性和可扩展性。工厂模式主要分为三种类型：简单工厂模式是工厂模式的基础版本，它定义了一个工厂类来创建产品对象。抽象产品 角色具体产品 角色工
go的工厂模式
z3551906947的博客
08-06 1131
工厂模式是一种常用的软件设计模式，它属于创建型模式之一，其核心思想是将对象的创建和使用分离，以此来提高代码的模块化和可维护性。定义：创建相关或依赖对象的家族，而不需明确指定具体类。提供一个接口以创建一族相关或依赖的对象，而不需要构造它们的具体类。适用场景：当需要生成多个产品族时。优点：易于扩展新的产品族，同时保持了产品的一致性。缺点：新增产品等级结构困难，增加了系统的复杂度。简单工厂模式是一种创建型设计模式，它使用一个工厂类根据传入的参数来决定创建出哪一种产品类的实例。
设计模式-工厂模式
m0_69323023的博客
10-16 1188
工厂模式
软件设计模式——工厂模式
qq_63814838的博客
10-04 1347
简单工厂模式、工厂方法模式、抽象工厂模式
qt工厂模式例子qt简单工程模式源码
07-04
3. Qt工厂模式工程 4. Qt工厂模式例程 5. Qt工厂模式例子 6. 简单工厂模式 部分源码实例: // 奔驰工厂 class BenzFactory : public AFactory { public: ICar* CreateCar() { return new BenzCar(); } }; // ...
AOC电视进入酒店模式和工厂模式的方法
06-15
测试机型：32m3095（其它机型未试，大同小异，自行测试） 测试时间：2022.06.15 进入酒店模式好处：可以设置...进入工厂模式好处：可以设置不正常的颜色，声音。恢复系统默认设置。好多功能，是英文的，我看不懂。
长虹LED39C2080i智能电视工程模式详解.doc
01-08
本文详细讲解了长虹LED39C2080i智能电视的工程模式，包括如何进入工程模式、工程模式的作用、工程模式菜单索引详解等内容。 一、如何进入工程模式： 要进入工程模式，需要遥控器按“节目源”出来节目源选择菜单，...
Java设计模式之工厂模式（Factory模式）介绍
09-03
**工厂模式**是一种常见的设计模式，它在Java中被广泛应用于创建对象实例。工厂模式的主要目的是将对象的创建过程封装起来，使得代码更加灵活且易于维护。通过使用工厂模式，我们可以将实例化对象的责任从客户端代码...
过滤器模式
xcosy
03-06 424
定义 过滤器模式(Intercepting Filter Pattern)，又称标准模式（Criteria Pattern），主要用于统一接收并过滤客户端的请求，根据过滤器的选择，将请求传送给对应的目标处理程序。 过滤器模式属于对象结构型模式。 要点 主要角色： 目标对象（Target）：处理请求，根据要求执行任务。 过滤器（Filter）：过滤器在请求处理程序执行请求之前或之后，执行某些任务。...
外观模式
xcosy
02-29 310
定义 外观（Facade）模式是一种通过为多个复杂的子系统提供一个统一的接口，而使这些子系统更加容易被访问的模式。该模式对外有一个统一接口，外部应用程序不用关心内部子系统的具体的细节，这样会大大降低应用程序的复杂度，提高了程序的可维护性。 外观模式属于对象结构型模式。 要点 外观（Facade）模式是“迪米特法则”的典型应用，优点： 降低了子系统与客户端之间的耦合度，使得子系统的变化不会影响调...
组合模式
xcosy
02-29 302
定义 组合（Composite）模式：又称作部分整体模式，它是一种将对象组合成树状的层次结构的模式，用来表示 “部分-整体” 的关系，使用户对单个对象和组合对象具有一致的访问性。 组合模式属于对象结构型模式。 要点 组合模式的优点： 组合模式使得客户端代码可以一致地处理单个对象和组合对象，无须关心自己处理的是单个对象，还是组合对象，这简化了客户端代码； 更容易在组合体内加入新的对象，客户端不会...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值