设计模式-3.2工厂模式

已于 2023-10-28 13:57:20 修改
阅读量56 收藏
点赞数
分类专栏： Java-设计模式分录 文章标签： 设计模式 java 开发语言
于 2023-07-13 16:36:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yueerba126/article/details/131705969
版权

⚡️ 工厂模式

  • 🛠️ 简单工厂模式:

    • 📌 描述: 建立一个实例化对象的类，该类中可以对多个对象进行实例化。
    • ⚠️ 注意: 它是一个具体的类，不是接口或抽象类。所有的对象创建请求都通过这个类的静态方法来完成。

  • 🛠️ 工厂方法模式:

    • 📌 描述: 定义了一个创建对象的抽象方法，由子类决定要实例化的类。
    • ⚠️ 注意: 在有新的类型的对象需要实例化时，只需增加相应的子类即可，无需修改已有的代码。

  • 🛠️ 抽象工厂模式:

    • 📌 描述: 定义了一个接口用于创建对象族，但无需明确指定具体类。
    • 📌 优点: 提供给客户端接口，避免了用户直接操作子类工厂。
    • ⚠️ 注意: 抽象工厂也将对象的实例化交给了具体的子类工厂，从而支持拓展。

⚠️ 注意: 工厂模式是面向对象编程中的一种设计模式，用于处理对象创建的问题，特别是当直接创建对象（使用new操作符）不便或不合适时。工厂模式将对象的创建和使用解耦，使得系统更加灵活、可扩展。

⚡️ 简单工厂模式(不属于GOF的23种经典设计模式）

🟢 结构

  • 抽象产品:

    • 📌 定义了产品的规范，描述了产品的主要特性和功能。

  • 具体产品:

    • 📌 实现或者继承了抽象产品的类。

  • 具体工厂:

    • 📌 提供了创建产品的方法，调用者通过它来获取新的产品对象。

🟢 优缺点

  • 优点:

    • 📌 封装了创建对象的过程，可以通过参数直接获取对象。
    • 📌 把对象的创建和业务逻辑层分开，便于扩展和维护。
    • ⚠️ 注意: 如果要实现新产品，直接修改工厂类即可，无需在原代码中进行大量修改。

  • 缺点:

    • 📌 增加新产品时需要修改工厂类的代码，这在一定程度上违背了“开闭原则”（软件实体应对扩展开放，对修改关闭）。

⚠️ 注意: 简单工厂模式适用于产品种类相对较少且不经常变动的场景，在复杂或频繁变动的产品需求场景下，可能就不太适用。

⚡️ 静态工厂模式(不属于GOF的23种经典设计模式）

🟢 特点

  • 静态方法:

    • 📌 工厂类中的方法通常定义为静态的，因此不需要创建工厂对象，直接通过工厂类名调用方法即可。

  • 创建对象:

    • 📌 通过调用工厂类中的静态方法来获取需要的对象。

🟢 优缺点

  • 优点:

    • 📌 无需创建工厂对象，直接调用方法即可，简单且方便。
    • 📌 通过静态方法封装对象创建的细节，使得调用者只关心如何使用对象。

  • 缺点:

    • 📌 由于静态方法无法继承和重写，所以静态工厂模式会限制子类的扩展和修改能力。
    • 📌 如果要增加新产品，仍然需要修改工厂类的代码，违背了“开闭原则”。

⚠️ 注意: 静态工厂模式适用于创建对象的过程稳定且不经常变动的场景。当产品种类或创建逻辑经常变动时，该模式可能会带来不便，因为每次变动都需要修改静态方法。

⚡️ 工厂方法模式

🟢 结构

  • 抽象工厂 (Abstract Factory):

    • 📌 提供了创建产品的接口。
    • 📌 调用者通过它访问具体工厂的工厂方法来创建产品。

  • 具体工厂 (Concrete Factory):

    • 📌 主要是实现抽象工厂中的抽象方法。
    • 📌 完成具体产品的创建。

  • 抽象产品 (Product):

    • 📌 定义了产品的规范。
    • 📌 描述了产品的主要特性和功能。

  • 具体产品(Concrete Product):

    • 📌 实现了抽象产品角色所定义的接口。
    • 📌 由具体工厂来创建，它与具体工厂之间是一一对应的。

🟢 优缺点

  • 优点:

    • 📌 用户只需知道具体工厂的名称，无须知道产品的具体创建过程。
    • 📌 当增加新的产品时，只需添加具体产品类和对应的具体工厂类，无需修改原有工厂，满足开闭原则。

  • 缺点:

    • 📌 每增加一个产品，就需增加一个具体产品类和一个对应的具体工厂类，增加了系统的复杂度。

⚠️ 注意: 工厂方法模式是面向对象设计的一种经典模式，它解决了代码与特定类的强耦合问题，使得增加新产品类别时，系统具有很好的可扩展性。

⚡️ 抽象工厂模式

在这里插入图片描述

🟢 结构

  • 抽象工厂 (Abstract Factory):

    • 📌 提供了创建产品的接口。
    • 📌 包含多个创建产品的方法，能够创建多个不同等级的产品。

  • 具体工厂 (Concrete Factory):

    • 📌 主要是实现抽象工厂中的抽象方法。
    • 📌 负责完成具体产品的创建。

  • 抽象产品 (Product):

    • 📌 定义了产品的规范。
    • 📌 描述了产品的主要特性和功能。
    • ⚠️ 注意: 抽象工厂模式有多个抽象产品。

  • 具体产品 (Concrete Product):

    • 📌 实现了抽象产品角色所定义的接口。
    • 📌 由具体工厂来创建。
    • ⚠️ 注意: 它与具体工厂之间是多对一的关系。

🟢 优缺点

  • 优点:

    • 📌 当一个产品族中的多个对象被设计成一起工作时，它能确保客户端始终只使用该产品族中的对象。

  • 缺点:

    • 📌 当产品族中需要增加一个新的产品时，所有的工厂类都需要进行修改，增加了维护的复杂性。

⚠️ 注意: 抽象工厂模式用于创建一系列相关或互相依赖的对象，而不指定它们具体的类。它提供了一个接口，由子类决定实例化哪一个类，从而使得客户与实际创建对象的类解耦。

⚡️ 使用场景

📌 简单工厂

  • 产品等级结构:

    • 📌 简单工厂用于生产同一等级结构中的任意产品。
    • ⚠️ 注意: 不支持拓展增加产品。

  • 适用场合:

    • 📌 举例: 只有瑞幸咖啡工厂（唯一的生产工厂，即只有这一个等级结构）。
    • 📌 该工厂只生产两种固定类型的咖啡：美式咖啡和拿铁咖啡。
    • ⚠️ 注意: 如果需要增加新的咖啡种类，简单工厂模式可能不太适用，因为它不支持轻易地拓展增加产品。
      在这里插入图片描述
package com.study.notes.design.patterns.pattern.create.factory.simple_factory.bean;

/**
 * @version v1.0
 * @ClassName: Coffee
 * @Description: 咖啡类
 * @Author: lzq
 */
public abstract class Coffee {

    public abstract String getName();

    //加糖
    public void addSugar() {
        System.out.println("加糖");
    }

    //加奶
    public void addMilk() {
        System.out.println("加奶");
    }
}


package com.study.notes.design.patterns.pattern.create.factory.simple_factory.bean;


/**
 * @version v1.0
 * @ClassName: AmericanCoffee
 * @Description: 没事咖啡
 * @Author: lzq
 */
public class AmericanCoffee extends Coffee {

    @Override
    public String getName() {
        return "美式咖啡";
    }
}


package com.study.notes.design.patterns.pattern.create.factory.simple_factory.bean;


/**
 * @version v1.0
 * @ClassName: LatteCoffee
 * @Description: 拿铁咖啡
 * @Author: lzq
 */
public class LatteCoffee extends Coffee {

    @Override
    public String getName() {
        return "拿铁咖啡";
    }
}


package com.study.notes.design.patterns.pattern.create.factory.simple_factory.factory;

import com.study.notes.design.patterns.pattern.create.factory.simple_factory.bean.LatteCoffee;
import com.study.notes.design.patterns.pattern.create.factory.simple_factory.bean.AmericanCoffee;
import com.study.notes.design.patterns.pattern.create.factory.simple_factory.bean.Coffee;

/**
 * @version v1.0
 * @ClassName: SimpleCoffeeFactory
 * @Description: 简单咖啡工厂类，用来生产咖啡
 * @Author: lzq
 */
public class SimpleCoffeeFactory {

    public Coffee createCoffee(String type) {
        //声明Coffee类型的变量，根据不同类型创建不同的coffee子类对象
        Coffee coffee = null;
        if ("american".equals(type)) {
            coffee = new AmericanCoffee();
        } else if ("latte".equals(type)) {
            coffee = new LatteCoffee();
        } else {
            throw new RuntimeException("对不起，您所点的咖啡没有");
        }

        return coffee;
    }
}


package com.study.notes.design.patterns.pattern.create.factory.simple_factory.store;


import com.study.notes.design.patterns.pattern.create.factory.simple_factory.bean.Coffee;
import com.study.notes.design.patterns.pattern.create.factory.simple_factory.factory.SimpleCoffeeFactory;

/**
 * @version v1.0
 * @ClassName: CoffeeStore
 * @Description: TODO(一句话描述该类的功能)
 * @Author: lzq
 */
public class CoffeeStore {

    public Coffee orderCoffee(String type) {

        SimpleCoffeeFactory factory = new SimpleCoffeeFactory();
        //调用生产咖啡的方法
        Coffee coffee = factory.createCoffee(type);

        //加配料
        coffee.addMilk();
        coffee.addSugar();

        return coffee;
    }
}


package com.study.notes.design.patterns.pattern.create.factory.simple_factory;

import com.study.notes.design.patterns.pattern.create.factory.simple_factory.bean.Coffee;
import com.study.notes.design.patterns.pattern.create.factory.simple_factory.store.CoffeeStore;

/**
 * @version v1.0
 * @ClassName: Client
 * @Description: TODO(一句话描述该类的功能)
 * @Author: lzq
 */
public class Client {
    public static void main(String[] args) {
        //创建咖啡店类对象
        CoffeeStore store = new CoffeeStore();
        Coffee coffee = store.orderCoffee("latte");

        System.out.println(coffee.getName());
    }
}

📌 工厂方法

  • 产品等级结构:

    • 📌 用于生产同一等级结构中的固定产品。
    • ⚠️ 注意: 支持拓展增加产品。

  • 适用场合:

    • 📌 举例: 除了原有的瑞幸咖啡工厂，现在还增加了星巴克咖啡工厂（仍然是同一等级结构）。
    • 📌 无论是瑞幸还是星巴克，他们都生产两种固定类型的咖啡：美式咖啡和拿铁咖啡。
    • ⚠️ 注意: 由于采用工厂方法模式，当我们需要新增其他品牌的咖啡工厂时，可以很方便地拓展。
      在这里插入图片描述
package com.study.notes.design.patterns.pattern.create.factory.factory_method.factory;

import com.study.notes.design.patterns.pattern.create.factory.factory_method.bean.Coffee;

/**
 * @version v1.0
 * @ClassName: CoffeeFactory
 * @Description: CoffeeFactory ： 抽象工厂
 * @Author: lzq
 */
public interface CoffeeFactory {

    //创建咖啡对象的方法
    Coffee createCoffee();
}


package com.study.notes.design.patterns.pattern.create.factory.factory_method.factory;

import com.study.notes.design.patterns.pattern.create.factory.factory_method.bean.AmericanCoffee;
import com.study.notes.design.patterns.pattern.create.factory.factory_method.bean.Coffee;

/**
 * @version v1.0
 * @ClassName: AmericanCoffeeFactory
 * @Description: 美式咖啡工厂对象，专门用来生产美式咖啡
 * @Author: lzq
 */
public class AmericanCoffeeFactory implements CoffeeFactory {

    @Override
    public Coffee createCoffee() {
        return new AmericanCoffee();
    }
}


package com.study.notes.design.patterns.pattern.create.factory.factory_method.factory;

import com.study.notes.design.patterns.pattern.create.factory.factory_method.bean.LatteCoffee;
import com.study.notes.design.patterns.pattern.create.factory.factory_method.bean.Coffee;

/**
 * @version v1.0
 * @ClassName: LatteCoffeeFactory
 * @Description: 拿铁咖啡工厂，专门用来生产拿铁咖啡
 * @Author: lzq
 */
public class LatteCoffeeFactory implements CoffeeFactory {

    @Override
    public Coffee createCoffee() {
        return new LatteCoffee();
    }
}


package com.study.notes.design.patterns.pattern.create.factory.factory_method.store;


import com.study.notes.design.patterns.pattern.create.factory.factory_method.factory.CoffeeFactory;
import com.study.notes.design.patterns.pattern.create.factory.factory_method.bean.Coffee;

/**
 * @version v1.0
 * @ClassName: CoffeeStore
 * @Description: TODO(一句话描述该类的功能)
 * @Author: lzq
 */
public class CoffeeStore {

    private CoffeeFactory factory;

    public void setFactory(CoffeeFactory factory) {
        this.factory = factory;
    }

    //点咖啡功能
    public Coffee orderCoffee() {
        Coffee coffee = factory.createCoffee();
        //加配料
        coffee.addMilk();
        coffee.addSugar();
        return coffee;
    }
}


package com.study.notes.design.patterns.pattern.create.factory.factory_method;

import com.study.notes.design.patterns.pattern.create.factory.factory_method.factory.CoffeeFactory;
import com.study.notes.design.patterns.pattern.create.factory.factory_method.factory.LatteCoffeeFactory;
import com.study.notes.design.patterns.pattern.create.factory.factory_method.store.CoffeeStore;
import com.study.notes.design.patterns.pattern.create.factory.factory_method.bean.Coffee;

/**
 * @version v1.0
 * @ClassName: Client
 * @Description: TODO(一句话描述该类的功能)
 * @Author: lzq
 */
public class Client {
    public static void main(String[] args) {
        //创建咖啡店对象
        CoffeeStore store = new CoffeeStore();
        //创建对象
        //CoffeeFactory factory = new AmericanCoffeeFactory();
        CoffeeFactory factory = new LatteCoffeeFactory();
        store.setFactory(factory);

        //点咖啡
        Coffee coffee = store.orderCoffee();

        System.out.println(coffee.getName());
    }
}

📌 抽象工厂

  • 产品族与产品等级结构:

    • 📌 用于生产不同产品族的全部产品。
    • 📌 有多个产品等级结构，每个等级结构对应多种产品。
    • ⚠️ 注意: 支持拓展增加产品；同时也支持增加产品族。

  • 适用场合:

    • 📌 举例: 除了原有的瑞幸和星巴克咖啡，现在这两个品牌的工厂都开始生产甜品（增加产品族）。
    • 📌 无论是瑞幸还是星巴克，他们不仅生产两种固定类型的咖啡：美式咖啡和拿铁咖啡，还生产各种甜品。
    • ⚠️ 注意: 由于采用抽象工厂模式，当我们需要新增其他品牌的咖啡工厂或新增其他种类的产品时，可以很方便地拓展。
      在这里插入图片描述
package com.study.notes.design.patterns.pattern.create.factory.abstract_factory.bean;

/**
 * @version v1.0
 * @ClassName: Coffee
 * @Description: 咖啡类
 * @Author: lzq
 */
public abstract class Coffee {

    public abstract String getName();

    //加糖
    public void addSugar() {
        System.out.println("加糖");
    }

    //加奶
    public void addMilk() {
        System.out.println("加奶");
    }
}


package com.study.notes.design.patterns.pattern.create.factory.abstract_factory.bean;

/**
 * @version v1.0
 * @ClassName: AmericanCoffee
 * @Description: 没事咖啡
 * @Author: lzq
 */
public class AmericanCoffee extends Coffee {

    @Override
    public String getName() {
        return "美式咖啡";
    }
}


package com.study.notes.design.patterns.pattern.create.factory.abstract_factory.bean;

/**
 * @version v1.0
 * @ClassName: LatteCoffee
 * @Description: 拿铁咖啡
 * @Author: lzq
 */
public class LatteCoffee extends Coffee {

    @Override
    public String getName() {
        return "拿铁咖啡";
    }
}


package com.study.notes.design.patterns.pattern.create.factory.abstract_factory.bean;

/**
 * @version v1.0
 * @ClassName: Dessert
 * @Description: 甜品抽象类
 * @Author: lzq
 */
public abstract class Dessert {

    public abstract void show();
}


package com.study.notes.design.patterns.pattern.create.factory.abstract_factory.bean;

/**
 * @version v1.0
 * @ClassName: MatchaMousse
 * @Description: 抹茶慕斯类
 * @Author: lzq
 */
public class MatchaMousse extends Dessert {
    @Override
    public void show() {
        System.out.println("抹茶慕斯");
    }
}


package com.study.notes.design.patterns.pattern.create.factory.abstract_factory.bean;


/**
 * @version v1.0
 * @ClassName: Trimisu
 * @Description: 提拉米苏类
 * @Author: lzq
 */
public class Trimisu extends Dessert {
    @Override
    public void show() {
        System.out.println("提拉米苏");
    }
}


package com.study.notes.design.patterns.pattern.create.factory.abstract_factory.factory;

import com.study.notes.design.patterns.pattern.create.factory.abstract_factory.bean.Dessert;
import com.study.notes.design.patterns.pattern.create.factory.abstract_factory.bean.Coffee;

/**
 * @version v1.0
 * @ClassName: DessertFactory
 * @Description: TODO(一句话描述该类的功能)
 * @Author: lzq
 */
public interface DessertFactory {

    //生产咖啡的功能
    Coffee createCoffee();

    //生产甜品的功能
    Dessert createDessert();
}


package com.study.notes.design.patterns.pattern.create.factory.abstract_factory.factory;

import com.study.notes.design.patterns.pattern.create.factory.abstract_factory.bean.AmericanCoffee;
import com.study.notes.design.patterns.pattern.create.factory.abstract_factory.bean.Coffee;
import com.study.notes.design.patterns.pattern.create.factory.abstract_factory.bean.Dessert;
import com.study.notes.design.patterns.pattern.create.factory.abstract_factory.bean.MatchaMousse;

/**
 * @version v1.0
 * @ClassName: AmericanDessertFactory
 * @Description: 美式风味的甜品工厂
 * 生产美式咖啡和抹茶慕斯
 * @Author: lzq
 */
public class AmericanDessertFactory implements DessertFactory {

    @Override
    public Coffee createCoffee() {
        return new AmericanCoffee();
    }

    @Override
    public Dessert createDessert() {
        return new MatchaMousse();
    }
}


package com.study.notes.design.patterns.pattern.create.factory.abstract_factory.factory;

import com.study.notes.design.patterns.pattern.create.factory.abstract_factory.bean.Trimisu;
import com.study.notes.design.patterns.pattern.create.factory.abstract_factory.bean.Coffee;
import com.study.notes.design.patterns.pattern.create.factory.abstract_factory.bean.Dessert;
import com.study.notes.design.patterns.pattern.create.factory.abstract_factory.bean.LatteCoffee;

/**
 * @version v1.0
 * @ClassName: ItalyDessertFactory
 * @Description: 意大利风味甜品工厂
 * 生产拿铁咖啡和提拉米苏甜品
 * @Author: lzq
 */
public class ItalyDessertFactory implements DessertFactory {

    @Override
    public Coffee createCoffee() {
        return new LatteCoffee();
    }

    @Override
    public Dessert createDessert() {
        return new Trimisu();
    }
}


package com.study.notes.design.patterns.pattern.create.factory.abstract_factory;

import com.study.notes.design.patterns.pattern.create.factory.abstract_factory.bean.Dessert;
import com.study.notes.design.patterns.pattern.create.factory.abstract_factory.bean.Coffee;
import com.study.notes.design.patterns.pattern.create.factory.abstract_factory.factory.AmericanDessertFactory;

/**
 * @version v1.0
 * @ClassName: Client
 * @Description: TODO(一句话描述该类的功能)
 * @Author: lzq
 */
public class Client {
    public static void main(String[] args) {
        //创建的是意大利风味甜品工厂对象
        //ItalyDessertFactory factory = new ItalyDessertFactory();
        AmericanDessertFactory factory = new AmericanDessertFactory();
        //获取拿铁咖啡和提拉米苏甜品
        Coffee coffee = factory.createCoffee();
        Dessert dessert = factory.createDessert();

        System.out.println(coffee.getName());
        dessert.show();
    }
}

⚡️ 经典工厂模式Collection.iterator方法

在这里插入图片描述

🟢 Collection 和 Iterator

  • 关系:

    • 📌 Collection 接口作为抽象工厂类。
    • 📌 ArrayList (以及其他如 HashSet, LinkedList 等) 为具体的工厂类。
    • 📌 Iterator 接口作为抽象商品类。
    • 📌 ArrayList 中的 iterator 内部类为具体的商品类。

  • 实现:

    • 📌 在 ArrayList (具体工厂) 中，iterator 方法创建了 Iterator 的具体实现 (具体商品) 的对象。

🟢 DateFormat

  • 📌 DateFormat 类中的 getInstance 方法使用的是工厂模式。
    • ⚠️ 注意: 通过 DateFormat.getInstance()，我们可以得到日期/时间格式化的具体实例，而不需要关心其具体实现。

🟢 Calendar

  • 📌 Calendar 类中的 getInstance 方法使用的是工厂模式。
    • ⚠️ 注意: 通过 Calendar.getInstance()，我们可以得到日历的具体实例，而不需要关心其具体实现，可以是 GregorianCalendar 或其他日历的实现。

⚠️ 注意: Java 标准库中有许多设计模式的应用，工厂模式只是其中之一。这些模式为开发者提供了方便的 API，同时隐藏了具体实现的细节。

yueerba126
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
PAF-Lab-3.2:PAF-Lab-3.2
03-13
6. **设计模式**：可能涉及到一些常见的设计模式，如单例、工厂、观察者等，这些是解决特定问题的常用方案。 7. **JVM原理**：了解Java虚拟机的工作机制，包括内存管理、垃圾回收等。 8. **单元测试**：使用JUnit或...
commons-collections-3.2.jar+commons-dbcp-1.2.1.jar+commons-pool-1.3.jar
03-07
Commons Pool是对象池设计模式的实现，主要用于提高对象复用的效率。对象池允许预先创建一组对象，应用程序在需要时可以从池中获取，而不是每次都创建新的对象，这降低了系统资源的开销。Commons Pool可以用来创建...
设计模式----工厂模式
apple_52793577的博客
11-29 1010
工厂模式，顾名思义，肯定是生产某样东西的，在Java中那肯定是生产对象的啦，在Java中，万物皆对象，传统地我们需要用到对象的时候，通常是new出来，比如我要一个Apple类的实例，就是Apple apple = new Apple();接下来我们就可以使用这个实例，但是这样的话就会造成耦合重的问题，比如现在要更换对象，程序中所有new对象的地方都要修改一遍，这样做就违背了开闭原则；
2、设计模式--工厂模式
zht245648124的博客
04-17 1428
Java 中的简单工厂模式、工厂方法模式和抽象工厂模式都属于创建型设计模式，它们的主要目的都是封装对象的创建过程，将对象的创建和使用分离开来，从而提高代码的可维护性和可扩展性。工厂模式利用了面向对象的封装特点，对外屏蔽实现过程。
创建型设计模式----工厂方法模式
前端与计算机相关知识的分享，博主的qq523235674
06-02 1633
工厂方法模式，又称工厂模式，通过定义工厂父类负责定义创建对象的公共接口，而子类则负责生成具体的对象。 将类的实例化（具体产品的创建）延迟到工厂类的子类（具体工厂）中完成，即由子类来决定应该实例化（创建）哪一个类。 工厂一旦需要生产新产品就需要修改工厂类的方法逻辑，违背了“开放 - 关闭原则 步骤1： 创建抽象工厂类，定义具体工厂的公共接口； 步骤2： 创建抽象产品类 ，定义具体产品的公共接口； 步骤3： 创建具体产品类（继承抽象产品类） & 定义生产的具体产品； 步骤4：创建具体工厂类（继承抽象工厂
安卓常见设计模式3.2------工厂模式，工厂方法模式，抽象工厂模式对比（Kotlin版）
jiet_h的博客
11-07 513
工厂模式是一种创建对象的模式，它通过一个工厂类来封装对象的创建过程。客户端只需要与工厂类交互，而无需直接实例化具体的产品对象。工厂方法模式是一种创建单个对象的模式，它定义了一个工厂方法接口，在具体的工厂类中实现该方法来创建具体的产品对象。，它提供了一个抽象工厂接口，该接口声明了一组创建产品对象的方法。具体的工厂类实现这些方法来创建具体的产品对象。抽象工厂模式适用于创建一系列相关产品的场景，每个具体工厂类负责创建特定产品族的对象。，它通过工厂类的静态方法或实例方法来创建具体产品对象。
设计模式-创建型模式-抽象工厂模式
qq_40788199的博客
06-04 696
C++设计模式-创建型-抽象工厂模式-源码
Java二十三种设计模式-抽象工厂模式（3/23）
探索IT世界
07-15 995
抽象工厂模式是一种创建型设计模式，用于创建一系列相关或相互依赖的对象，而不需要指定它们具体的类。这种模式提供了一个接口，用于生成一组相关的对象，而客户端不需要知道这些对象的具体类。定义了创建一系列相关或依赖对象的接口。它是一个抽象角色，不实现具体的创建逻辑。定义了产品的接口，是所有具体产品类的共同父类。它是一个抽象角色，不实现具体的产品类。抽象工厂模式是处理复杂系统中对象创建问题的有效工具。通过本文的深入分析，希望读者能够对抽象工厂模式有更全面的理解，并在实际开发中做出合理的设计选择。
设计模式1-工厂模式
weixin_42120861的博客
04-15 1529
简单工厂模式（Simple Factory Pattern）是一种创建型设计模式，它提供了一个简单的工厂类，根据不同的参数来实例化不同的对象，而客户端无需直接创建对象，只需要通过工厂类来获取所需的对象。简单工厂模式封装了对象的创建过程，使客户端代码与具体类的实现解耦，提高了代码的灵活性和可维护性。客户端根据需要选择合适的工厂类，并通过工厂类创建按钮和窗口，而无需关心具体产品的实现细节。下面是一个抽象工厂模式的示例，演示了如何创建一个简单的 GUI（图形用户界面）工厂，用于创建不同操作系统下的按钮和窗口。
Java设计模式-工厂模式
Java硬件工程师的博客
02-09 3371
1.概述 需求：设计一个咖啡店点餐系统。 设计一个咖啡类（Coffee），并定义其两个子类（美式咖啡【AmericanCoffee】和拿铁咖啡【LatteCoffee】）；再设计一个咖啡店类（CoffeeStore），咖啡店具有点咖啡的功能。 具体类的设计如下： 在java中，万物皆对象，这些对象都需要创建，如果创建的时候直接new该对象，就会对该对象耦合严重(CoffeeStore对AmericanCoffr)，假如我们要更换对象，所有new对象的地方都需要修改一遍，这显然违背了软件设计的开闭原则。如果
设计模式-服务定位器模式
jike11231的博客
03-01 1091
设计模式-策略模式（服务定位器模式）
Java设计模式--工厂模式
南方嘉木的博客
02-03 1675
依赖抽象原则：创建对象实例时，不要之间new类，而是把这个动作交给工厂的方法并返回。
GEF-ALL-3.2.zip_GEF-ALL-3.6.2 pudn_gef_gef 3.2 download_gef java
09-20
在这一版本中，开发者可以找到关于如何构建图形编辑器的基本组件和设计模式，例如图元工厂（MetaFactory）、图形模型（Graphical Model）、图形视图（Graphical View）以及编辑领域（Edit Domain）。同时，源代码...
NHibernate-3.2 源码
03-06
- **设计模式**：NHibernate运用了许多设计模式，如工厂模式、单例模式、代理模式等，研究源码可以帮助我们提升设计能力。 - **单元测试**：了解如何编写针对ORM的测试用例，确保代码的正确性和稳定性。 - **持续...
(一)js前端开发中设计模式前篇之对象
峰会路转的博客
07-17 226
改进版与基础版要分开测试，不然会互相影响到。
模板方法原理与C++实现
Black.Spider的博客
07-15 296
定义一个操作中的算法骨架（稳定的），而将一些步骤的实现延迟到子类中（变化的）。模板方法使得子类可以复用一个算法的结构，而只改变（重写）这个算法的特定步骤。模板方法是一种非常实用且常见的设计模式，它使用简单的机制（虚函数）为应用程序框架提供了灵活的扩展点。模板方法中被模板方法调用的虚函数可以有具体实现，也可以没有任何实现（纯虚函数），但一般访问权限为protected，因为作为算法的一部分，它没有对外单独开放的必要。
(三)js前端开发中设计模式之工厂模式
最新发布
峰会路转的博客
07-17 257
工厂模式是一种创建型设计模式，它可以帮助我们根据需求创建对象。
java面向对象——抽象类
Misnearch的博客
07-14 687
final修饰的类，不能有子类。abstract修饰的类，不能实例化。不能用abstract修饰私有方法、静态方法、final的方法、final的类。私有方法不能重写避免静态方法使用类进行调用final的方法不能被重写final修饰的类不能有子类。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

yueerba126

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值