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

1.创建型设计模式

1.1 简单工厂模式

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

代码：

// 包声明，定义当前类所在的包路径
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) {// 声明产品对象变量，初始化为nullProduct 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特有的信息显示功能*/@Overridepublic void info() {// 输出产品A的信息System.out.println("产品的信息：A");}
}/*** 具体产品B类* 继承自抽象产品类Product，实现具体的产品B功能*/
class ProductB extends Product {/*** 重写父类的抽象方法info()* 实现产品B特有的信息显示功能*/@Overridepublic void info() {// 输出产品B的信息System.out.println("产品的信息：B");}
}

1.2 工厂方法

// 包声明，定义当前类所在的包路径
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的实例*/@Overridepublic Product createProduct() {// 返回产品A的具体实例return new ProductA();}
}/*** 具体工厂B类* 实现抽象工厂接口，专门负责创建产品B* 每个具体工厂只负责创建一种产品，符合单一职责原则*/
class FactoryB implements Factory {/*** 实现抽象工厂方法，创建产品B的实例* @return 产品B的实例*/@Overridepublic 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 {@Overridepublic void info() {System.out.println("产品的信息： A");}
}/*** 具体产品B类* 实现implements抽象产品接口，提供产品B的具体实现* 每个具体产品类实现一种产品的具体功能*/
class ProductB implements Product {/*** 实现抽象方法info()* 输出产品B的具体信息*/@Overridepublic void info() {// 输出产品B的信息System.out.println("产品的信息：B");}
}

补充官方资料：

1.3 抽象工厂

// 包声明，定义当前类所在的包路径
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的实例*/@Overridepublic ProductA createProductA() {// 返回产品族1中的产品A1return new ProductA1();}/*** 实现抽象方法，创建产品族1中的产品B1* @return 产品B1的实例*/@Overridepublic ProductB createProductB() {// 返回产品族1中的产品B1return new ProductB1();}
}/*** 具体工厂2类* 实现抽象工厂接口，专门负责创建产品族2的所有产品* 产品族2包括：ProductA2和ProductB2* 每个具体工厂负责创建一个完整的产品族*/
class Factory2 implements Factory {/*** 实现抽象方法，创建产品族2中的产品A2* @return 产品A2的实例*/@Overridepublic ProductA createProductA() {// 返回产品族2中的产品A2return new ProductA2();}/*** 实现抽象方法，创建产品族2中的产品B2* @return 产品B2的实例*/@Overridepublic ProductB createProductB() {// 返回产品族2中的产品B2return new ProductB2();}
}/*** 抽象产品A接口* 定义产品A的通用接口，所有具体产品A都必须实现这个接口* 产品A是产品族中的一个产品等级*/
interface ProductA {/*** 抽象方法：显示产品信息* 所有具体产品A都必须实现这个方法*/public void info();
}/*** 具体产品A1类* 实现抽象产品A接口，属于产品族1* 产品族1中的产品A1的具体实现*/
class ProductA1 implements ProductA {/*** 实现抽象方法info()* 输出产品A1的具体信息*/@Overridepublic void info() {// 输出产品族1中产品A1的信息System.out.println("产品的信息：A1");}
}/*** 具体产品A2类* 实现抽象产品A接口，属于产品族2* 产品族2中的产品A2的具体实现*/
class ProductA2 implements ProductA {/*** 实现抽象方法info()* 输出产品A2的具体信息*/@Overridepublic 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的具体信息*/@Overridepublic void info() {// 输出产品族1中产品B1的信息System.out.println("产品的信息：B1");}
}/*** 具体产品B2类* 实现抽象产品B接口，属于产品族2* 产品族2中的产品B2的具体实现*/
class ProductB2 implements ProductB {/*** 实现抽象方法info()* 输出产品B2的具体信息*/@Overridepublic void info() {// 输出产品族2中产品B2的信息System.out.println("产品的信息：B2");}
}

1.4 生成器模式

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*/@Overridepublic void BuildPart() {product.Add("A");  // 添加组件Aproduct.Add("B");  // 添加组件Bproduct.Add("C");  // 添加组件Cproduct.Add("D");  // 添加组件Dproduct.Add("E");  // 添加组件Eproduct.Add("F");  // 添加组件F}/*** 返回构建完成的产品* @return 包含6个组件的完整产品*/@Overridepublic 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（简化版本）*/@Overridepublic void BuildPart() {product.Add("A");  // 添加组件Aproduct.Add("B");  // 添加组件Bproduct.Add("C");  // 添加组件C}/*** 返回构建完成的产品* @return 包含3个组件的简化产品*/@Overridepublic 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");  // 换行}
}