设计模式 笔记1 | 五个创建型模式 | Java 语言实现 | 工厂方法设计模式 | 抽象工厂模式 |建造者模式 | 单例模式 | 原型模式

在使用设计模式前，我们先用常见的方法来实现封装水果类，以及水果的继承类苹果和橘子

1. 定义一个水果抽象类

public abstract class Fruit {
       // 水果抽象类
    private final String name;

    public Fruit(String name){
   
        this.name = name;
    }

    @Override
    public String toString() {
   
        return name + "@" + hashCode(); // 打印当前水果名称和 哈希值
    }
}

2. 定义实现的子类

// 苹果
class Apple extends Fruit{
   
    public Apple(){
   
        super("苹果");
    }
}
// 橘子
class Origin extends Fruit{
   
    public Origin(){
   
        super("橘子");
    }
}

3. 运行测试

public class Demo {
   
    public static void main(String[] args) {
   
        System.out.println(new Apple());
        System.out.println(new Origin());
    }
}
// 输出结果
// 苹果@685325104
// 橘子@460141958

接下来我们通过一些设计模式来改写上面的例子，以便体会不同设计模式的特点。

一、工厂方法设计模式

---

工厂模式定义：定义一个创建产品对象的工厂接口，将产品对象的实际创建工作推迟到具体工厂类中。

在学习工厂方法设计模式前，我们先了解了解简单的工厂模式，简单工厂模式不归属于23种设计模式中。

在简单工厂模式中创建实例的方法通常为静态（static）方法，因此简单工厂模式又称为静态工厂方法模式。

优点：

• 使得工厂和产品区分明确
• 客户无需知道所需创建具体产品的类名，只需知道参数

缺点：

• 扩展性差，增加新产品时不得不修改工作逻辑。
• 简单工厂模式会增加系统中类的个数，增加系统的复杂性和理解难度
• 简单工厂模式使用了 static 工厂方法，无法实现继承
• 违背了开闭原则

应用场景：
产品种类相对较少时，可以考虑使用简单工厂模式。
主要组成：

• 简单工厂（SimpleFactory），是简单工厂模式的核心，负责实现创建所有实例的内部逻辑，工厂类创建产品类的方法可以被外界直接调用，创建所需的产品对象
• 抽象产品（Product），是简单工厂创建所有对象的父类，负责描述所有实例共有的公共接口
• 具体产品（Concrete Product），是简单工厂模式的创建目标

模板代码：

// 简单工厂模式
public class Demo{
   
    // 抽象产品
    interface Product{
   
        void show();
    }
    // 具体产品: Product A
    static class ConcreteProduct1 implements Product{
   

        @Override
        public void show() {
   
            System.out.println("具体产品1显示");
        }
    }
    // 具体产品: Product B
    static class ConcreteProduct2 implements Product{
   

        @Override
        public void show() {
   
            System.out.println("具体产品2显示");
        }
    }
    // 标记产品
    final class Const{
   
        final static int A = 0;
        final static int B = 1;
    }
    static class SimpleFactory{
   
        public static Product makeProduct(int type){
   
            switch (type){
   
                case Const.A:
                    return new ConcreteProduct1();
                case Const.B:
                    return new ConcreteProduct2();
            }
            return null;
        }
    }

    public static void main(String[] args) {
   
        Product productA = SimpleFactory.makeProduct(Const.A);
        Product productB = SimpleFactory.makeProduct(Const.B);
        assert productA != null;
        productA.show();
        assert productB != null;
        productB.show();
    }
}

工厂方法模式定义：是对简单工厂模式的进一步抽象化，符合开闭原则

优点：

• 用户只需知道具体工厂名称就可以获得需要的产品，无须知道产品的具体创建过程
• 灵活性强，对于新产品创建，只需多写一个相应的工厂类
• 解耦合，符合迪米特法则、依赖倒置原则和里氏替换原则

缺点：

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

应用场景：

• 用户只需知道产品的工厂名，而不知道具体的产品名
• 创建对象的任务由多个具体子工厂中的某一个完成，而抽象工厂只提供创建产品的接口

1.1 主要组成与模板代码

主要组成：

• 抽象工厂（Abstract Factory），提供了创建产品的接口，调用者通过它访问具体的工厂方法 newProduct() 来创建产品
• 具体工厂（ConcreteFactory），主要是实现抽象工厂中的抽象方法，完成具体产品的创建
• 抽象产品（Product），定义了产品的规范，描述了产品的主要特性和功能
• 具体产品（ConcreteProduct），实现了抽象产品角色所定义的接口，由具体的工厂创建

模板代码：

// 工厂方法模式
// 抽象产品
interface Product{
   
    public void show();
}
// 具体产品 1: 实现抽象产品中的抽象方法
class ConcreteProduct1 implements Product{
   
    @Override
    public void show() {
   
        System.out.println("具体产品1 展示");
    }
}
// 具体产品2: 实现抽象产品中的抽象方法
class ConcreteProduct2 implements Product{
   

    @Override
    public void show() {
   
        System.out.println("具体产品2 显示");
    }
}
// 抽象工厂
interface AbstractFactory{
   
    public Product newProduct();
}
// 具体工厂1 : 实现了产品1的生成方法
class ConcreteFactory1 implements AbstractFactory{
   

    @Override
    public Product newProduct() {
   
        System.out.println("具体工厂1生成 --> 具体产品1...");
        return new ConcreteProduct1();
    }
}
// 具体工厂2: 实现了产品2的生成方法
class ConcreteFactory2 implements AbstractFactory{
   
    @Override
    public Product newProduct() {
   
        System.out.println("具体工厂2生成 --> 具体产品2...");
        return new ConcreteProduct2();
    }
}
public class Demo{
   
    public static void main(String[] args) {
   
        ConcreteFactory1 factory1 = new ConcreteFactory1();
        ConcreteFactory2 factory2 = new ConcreteFactory2();
        Product product1 = factory1.newProduct();
        Product product2 = factory2.newProduct();
        product1.show();
        product2.show();
    }
}

1.2 应用案例

基于之前水果的例子，我们使用抽象类+泛型，将水果工厂类进一步划分成具体的水果工厂类

public abstract class FruitFactory<T extends Fruit> {
   
    public abstract T getFruit();
}

class AppleFactory extends FruitFactory<Apple>{
   
    @Override
    public Apple getFruit() {
   
        return new Apple();
    }
}
class OriginFactory extends FruitFactory&l