设计模式-创建型设计模式

1.创建型设计模式

1.1 简单工厂模式

存在的问题：不符合开闭原则（对修改关闭对扩展开放）

代码：

java 复制代码

// 包声明，定义当前类所在的包路径
package patterns.A简单工厂模式;

/**
 * 简单工厂模式演示类
 * 简单工厂模式：根据传入的参数决定创建哪种类型的产品对象
 * 优点：客户端不需要知道具体产品的创建过程，只需要传入类型参数
 * 缺点：工厂类职责过重，违反开闭原则（添加新产品需要修改工厂类）
 */
public class SimpleFactory {
    /**
     * 程序入口点
     * @param args 命令行参数
     */
    public static void main(String[] args) {
        // 通过工厂类创建类型为"A"的产品对象
        Product productA = Factory.createProduct("A");
        // 调用产品A的info方法，输出产品信息
        productA.info();

        // 通过工厂类创建类型为"B"的产品对象
        Product productB = Factory.createProduct("B");
        // 注意：这里没有调用productB.info()，所以不会输出产品B的信息
    }
}

/**
 * 抽象产品类
 * 定义了产品的通用接口和基本功能
 * 抽象类的特点：
 * 1.可以写抽象方法（必须被子类实现）
 * 2.也可以写私有方法（只能在本类中使用）
 * 3.也可以写带有方法体的方法（可以有具体实现）
 */
abstract class Product {
    /**
     * 抽象方法：显示产品信息
     * 所有具体产品类都必须实现这个方法
     */
    public abstract void info();//产品信息

    /**
     * 私有方法：输出产品名称
     * @param name 产品名称
     * 注意：这是私有方法，只能在Product类内部调用
     */
    private void name(String name) {
        System.out.println(name);
    }
}

/**
 * 工厂类
 * 负责根据传入的类型参数创建对应的产品对象
 * 这是简单工厂模式的核心类
 */
class Factory {
    /**
     * 静态工厂方法：根据产品类型创建对应的产品对象
     * 注意：静态方法-类名.静态方法（可以直接被外界调用，创建所需对象）
     * @param type 产品类型（"A"或"B"）-Product
     * @return 对应的产品对象，如果类型不存在则返回null
     */
    public static Product createProduct(String type) {
        // 声明产品对象变量，初始化为null
        Product product = null;

        // 使用switch语句根据类型参数决定创建哪种产品（也可以用if）
        switch (type) {
            case "A":
                // 创建产品A的实例
                product = new ProductA();
                break;
            case "B":
                // 创建产品B的实例
                product = new ProductB();
                break;
            default:
                // 如果传入的类型不是"A"或"B"，输出错误信息
                System.out.println("没有 " + type + " 类型的产品！");
                break;
        }

        // 返回创建的产品对象（如果类型不存在则返回null）
        return product;
    }
}

/**
 * 具体产品A类
 * 继承自抽象产品类Product，实现具体的产品A功能
 */
class ProductA extends Product {

    /**
     * 重写父类的抽象方法info()
     * 实现产品A特有的信息显示功能
     */
    @Override
    public void info() {
        // 输出产品A的信息
        System.out.println("产品的信息：A");
    }
}

/**
 * 具体产品B类
 * 继承自抽象产品类Product，实现具体的产品B功能
 */
class ProductB extends Product {

    /**
     * 重写父类的抽象方法info()
     * 实现产品B特有的信息显示功能
     */
    @Override
    public void info() {
        // 输出产品B的信息
        System.out.println("产品的信息：B");
    }
}

1.2 工厂方法

java 复制代码

// 包声明，定义当前类所在的包路径
package patterns.B工厂方法模式;

/**
 * 工厂方法模式演示类
 * 工厂方法模式：定义一个用于创建对象的接口，让子类决定实例化哪一个类
 * 优点：符合开闭原则，添加新产品时只需要添加新的工厂类，不需要修改现有代码
 * 缺点：类的数量增加，系统复杂度提高
 * 与简单工厂模式的区别：工厂方法模式将工厂抽象化，每个具体工厂只负责创建一种产品
 */
public class FactoryMethod {
    /**
     * 程序入口点
     * @param args 命令行参数
     */
    public static void main(String[] args) {
        // 创建具体工厂A的实例，使用多态：父类引用指向子类对象
        Factory factoryA = new FactoryA();
        // 父类 对象名 = new 子类(); 这是多态的基本用法

        // 通过工厂A创建产品A对象
        Product productA = factoryA.createProduct();
        // 注释掉的代码：直接创建产品对象，不符合工厂方法模式的设计原则
        // Product productA = new ProductA();
        // 调用产品A的info方法，输出产品信息
        productA.info();

        // 创建具体工厂B的实例
        Factory factoryB = new FactoryB();

        // 通过工厂B创建产品B对象
        Product productB = factoryB.createProduct();
        // 调用产品B的info方法，输出产品信息
        productB.info();
    }
}

/**
 * 抽象工厂接口
 * 定义创建产品的抽象方法，由具体工厂类实现
 * 工厂方法模式的核心：将工厂抽象化，每个具体工厂负责创建一种产品
 */
interface Factory {
    /**
     * 抽象工厂方法：创建产品对象
     * @return 创建的产品对象
     */
    public Product createProduct();
}

/**
 * 具体工厂A类
 * 实现抽象工厂接口，专门负责创建产品A
 * 每个具体工厂只负责创建一种产品，符合单一职责原则
 */
class FactoryA implements Factory {

    /**
     * 实现抽象工厂方法，创建产品A的实例
     * @return 产品A的实例
     */
    @Override
    public Product createProduct() {
        // 返回产品A的具体实例
        return new ProductA();
    }
}

/**
 * 具体工厂B类
 * 实现抽象工厂接口，专门负责创建产品B
 * 每个具体工厂只负责创建一种产品，符合单一职责原则
 */
class FactoryB implements Factory {

    /**
     * 实现抽象工厂方法，创建产品B的实例
     * @return 产品B的实例
     */
    @Override
    public Product createProduct() {
        // 返回产品B的具体实例
        return new ProductB();
    }
}

/**
 * 抽象产品接口
 * 定义产品的通用接口，所有具体产品都必须实现这个接口
 * 使用接口而不是抽象类，因为接口更灵活，支持多重实现
 */
interface Product {
    // 注释掉的代码：在接口中，方法默认是public abstract的
    // public abstract void info();
    /**
     * 抽象方法：显示产品信息
     * 接口中的方法默认是public abstract的，可以省略这些修饰符
     */
    public void info();
}

/**
 * 具体产品A类
 * 实现implements抽象产品接口，提供产品A的具体实现
 * 每个具体产品类实现一种产品的具体功能
 */
class ProductA implements Product {


    @Override
    public void info() {
        System.out.println("产品的信息： A");
    }
}

/**
 * 具体产品B类
 * 实现implements抽象产品接口，提供产品B的具体实现
 * 每个具体产品类实现一种产品的具体功能
 */
class ProductB implements Product {

    /**
     * 实现抽象方法info()
     * 输出产品B的具体信息
     */
    @Override
    public void info() {
        // 输出产品B的信息
        System.out.println("产品的信息：B");
    }
}

补充官方资料：

1.3 抽象工厂

java 复制代码

// 包声明，定义当前类所在的包路径
package patterns.C抽象工厂模式;

/**
 * 抽象工厂模式演示类
 * 抽象工厂模式：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类
 * 优点：能够保证创建的对象属于同一个产品族，符合开闭原则
 * 缺点：难以扩展新的产品种类，需要修改抽象工厂接口
 * 适用场景：需要创建多个产品族，且每个产品族有多个产品等级结构
 * 与工厂方法模式的区别：抽象工厂模式创建的是产品族，工厂方法模式创建的是单个产品
 */
public class AbstractFactory {
    /**
     * 程序入口点
     * @param args 命令行参数
     */
    public static void main(String[] args) {
        // 创建具体工厂1的实例，该工厂可以创建产品族1的所有产品
        Factory factory1 = new Factory1();

        // 通过工厂1创建产品A1（属于产品族1）
        ProductA productA = factory1.createProductA();
        // 调用产品A1的info方法，输出产品信息
        productA.info();

        // 创建具体工厂2的实例，该工厂可以创建产品族2的所有产品
        Factory factory2 = new Factory2();

        // 通过工厂2创建产品B2（属于产品族2）
        ProductB productB = factory2.createProductB();
        // 调用产品B2的info方法，输出产品信息
        productB.info();
    }
}

/**
 * 抽象工厂接口
 * 定义创建一系列相关产品的抽象方法
 * 每个具体工厂实现这个接口，负责创建属于同一产品族的所有产品
 * 抽象工厂模式的核心：一个工厂可以创建多种不同类型但相关的产品
 */
interface Factory {
    /**
     * 抽象方法：创建产品A
     * @return 产品A的实例
     */
    public ProductA createProductA();

    /**
     * 抽象方法：创建产品B
     * @return 产品B的实例
     */
    public ProductB createProductB();
}

/**
 * 具体工厂1类
 * 实现抽象工厂接口，专门负责创建产品族1的所有产品
 * 产品族1包括：ProductA1和ProductB1
 * 每个具体工厂负责创建一个完整的产品族
 */
class Factory1 implements Factory {

    /**
     * 实现抽象方法，创建产品族1中的产品A1
     * @return 产品A1的实例
     */
    @Override
    public ProductA createProductA() {
        // 返回产品族1中的产品A1
        return new ProductA1();
    }

    /**
     * 实现抽象方法，创建产品族1中的产品B1
     * @return 产品B1的实例
     */
    @Override
    public ProductB createProductB() {
        // 返回产品族1中的产品B1
        return new ProductB1();
    }
}

/**
 * 具体工厂2类
 * 实现抽象工厂接口，专门负责创建产品族2的所有产品
 * 产品族2包括：ProductA2和ProductB2
 * 每个具体工厂负责创建一个完整的产品族
 */
class Factory2 implements Factory {

    /**
     * 实现抽象方法，创建产品族2中的产品A2
     * @return 产品A2的实例
     */
    @Override
    public ProductA createProductA() {
        // 返回产品族2中的产品A2
        return new ProductA2();
    }

    /**
     * 实现抽象方法，创建产品族2中的产品B2
     * @return 产品B2的实例
     */
    @Override
    public ProductB createProductB() {
        // 返回产品族2中的产品B2
        return new ProductB2();
    }
}

/**
 * 抽象产品A接口
 * 定义产品A的通用接口，所有具体产品A都必须实现这个接口
 * 产品A是产品族中的一个产品等级
 */
interface ProductA {
    /**
     * 抽象方法：显示产品信息
     * 所有具体产品A都必须实现这个方法
     */
    public void info();
}

/**
 * 具体产品A1类
 * 实现抽象产品A接口，属于产品族1
 * 产品族1中的产品A1的具体实现
 */
class ProductA1 implements ProductA {

    /**
     * 实现抽象方法info()
     * 输出产品A1的具体信息
     */
    @Override
    public void info() {
        // 输出产品族1中产品A1的信息
        System.out.println("产品的信息：A1");
    }
}

/**
 * 具体产品A2类
 * 实现抽象产品A接口，属于产品族2
 * 产品族2中的产品A2的具体实现
 */
class ProductA2 implements ProductA {

    /**
     * 实现抽象方法info()
     * 输出产品A2的具体信息
     */
    @Override
    public void info() {
        // 输出产品族2中产品A2的信息
        System.out.println("产品的信息：A2");
    }
}

/**
 * 抽象产品B接口
 * 定义产品B的通用接口，所有具体产品B都必须实现这个接口
 * 产品B是产品族中的另一个产品等级
 */
interface ProductB {
    /**
     * 抽象方法：显示产品信息
     * 所有具体产品B都必须实现这个方法
     */
    public void info();
}

/**
 * 具体产品B1类
 * 实现抽象产品B接口，属于产品族1
 * 产品族1中的产品B1的具体实现
 */
class ProductB1 implements ProductB {

    /**
     * 实现抽象方法info()
     * 输出产品B1的具体信息
     */
    @Override
    public void info() {
        // 输出产品族1中产品B1的信息
        System.out.println("产品的信息：B1");
    }
}

/**
 * 具体产品B2类
 * 实现抽象产品B接口，属于产品族2
 * 产品族2中的产品B2的具体实现
 */
class ProductB2 implements ProductB {

    /**
     * 实现抽象方法info()
     * 输出产品B2的具体信息
     */
    @Override
    public void info() {
        // 输出产品族2中产品B2的信息
        System.out.println("产品的信息：B2");
    }
}

1.4 生成器模式

java 复制代码

package patterns.C生成器模式;

import java.util.*;

/**
 * 建造者模式（Builder Pattern）示例
 * 
 * 建造者模式是一种创建型设计模式，它允许你分步骤创建复杂对象。
 * 该模式让你使用相同的创建代码生成不同类型和形式的对象。
 * 
 * 主要组成部分：
 * 1. Director（指挥者）：负责调用建造者来构建产品
 * 2. Builder（建造者抽象类）：定义构建产品的接口
 * 3. ConcreteBuilder（具体建造者）：实现具体的构建过程
 * 4. Product（产品）：最终构建的复杂对象
 */
public class Main {
    public static void main(String[] args) {
        // 创建指挥者对象，负责协调建造过程
        Director director = new Director();

        // 使用Builder1构建第一个产品
        Builder builder1 = new Builder1();
        director.Construct(builder1);  // 指挥者调用建造者构建产品
        Product product1 = builder1.getResult();  // 获取构建完成的产品
        product1.show();  // 展示产品组成

        System.out.println("-------------------");

        // 使用Builder2构建第二个产品
        Builder builder2 = new Builder2();
        director.Construct(builder2);  // 指挥者调用建造者构建产品
        Product product2 = builder2.getResult();  // 获取构建完成的产品
        product2.show();  // 展示产品组成
    }
}

/**
 * Director（指挥者）类
 * 
 * 指挥者负责定义构建产品的步骤顺序，它知道如何调用建造者来构建产品。
 * 指挥者不直接创建产品，而是通过调用建造者的方法来构建产品。
 * 这样可以确保产品的构建过程是一致的，同时允许不同的建造者创建不同的产品。
 */
class Director {
    /**
     * 构建产品的方法
     * @param builder 具体的建造者对象
     */
    public void Construct(Builder builder) {
        // 调用建造者的构建方法来构建产品的各个部分
        builder.BuildPart();
    }
}

/**
 * Builder（建造者）抽象类
 * 
 * 定义了构建产品的抽象接口，包含两个主要方法：
 * 1. BuildPart() - 构建产品的各个部分
 * 2. getResult() - 返回构建完成的产品
 * 
 * 不同的具体建造者可以有不同的构建实现，从而创建不同配置的产品。
 */
abstract class Builder {
    /**
     * 构建产品各个部分的抽象方法
     * 具体的建造者需要实现这个方法，定义如何构建产品的各个组件
     */
    public abstract void BuildPart();//产品的零件

    /**
     * 获取构建完成的产品
     * @return 构建完成的产品对象
     */
    public abstract Product getResult();
}

/**
 * Builder1（具体建造者1）类
 * 
 * 实现了Builder抽象类，定义了第一种产品的构建方式。
 * 这个建造者会构建一个包含6个组件（A、B、C、D、E、F）的完整产品。
 */
class Builder1 extends Builder {
    // 正在构建的产品对象
    Product product = new Product();

    /**
     * 构建产品的各个部分
     * Builder1会添加6个组件：A、B、C、D、E、F
     */
    @Override
    public void BuildPart() {
        product.Add("A");  // 添加组件A
        product.Add("B");  // 添加组件B
        product.Add("C");  // 添加组件C
        product.Add("D");  // 添加组件D
        product.Add("E");  // 添加组件E
        product.Add("F");  // 添加组件F
    }

    /**
     * 返回构建完成的产品
     * @return 包含6个组件的完整产品
     */
    @Override
    public Product getResult() {
        return product;
    }
}

/**
 * Builder2（具体建造者2）类
 * 
 * 实现了Builder抽象类，定义了第二种产品的构建方式。
 * 这个建造者会构建一个包含3个组件（A、B、C）的简化产品。
 * 与Builder1相比，这是一个更简单的产品配置。
 */
class Builder2 extends Builder {
    // 正在构建的产品对象
    Product product = new Product();

    /**
     * 构建产品的各个部分
     * Builder2会添加3个组件：A、B、C（简化版本）
     */
    @Override
    public void BuildPart() {
        product.Add("A");  // 添加组件A
        product.Add("B");  // 添加组件B
        product.Add("C");  // 添加组件C
    }

    /**
     * 返回构建完成的产品
     * @return 包含3个组件的简化产品
     */
    @Override
    public Product getResult() {
        return product;
    }
}

/**
 * Product（产品）类
 * 
 * 表示最终构建的复杂对象。在这个例子中，产品由多个组件组成。
 * 产品类提供了添加组件和展示产品组成的功能。
 * 
 * 建造者模式的优势：
 * 1. 可以分步骤构建复杂对象
 * 2. 可以使用相同的构建代码生成不同的产品
 * 3. 将构建过程与表示分离
 * 4. 便于扩展新的产品类型
 */
class Product {
    // 存储产品组件的列表
    List<String> parts = new ArrayList<String>();

    /**
     * 向产品中添加一个组件
     * @param part 要添加的组件名称
     */
    public void Add(String part) {
        parts.add(part);
    }

    /**
     * 展示产品的组成
     * 输出产品包含的所有组件
     */
    public void show() {
        System.out.print("产品的组成：");
        // 遍历所有组件并输出
        for (String s : parts)
            System.out.print(s + " ");

        System.out.print("\n");  // 换行
    }
}