工厂模式学习

简单工厂模式（静态工厂模式）

介绍：
1、简单工厂模式是属于创建型模式，是工厂模式的一种，简单工厂模式是由一个工厂对象决定创建出哪种产品的实例。是工厂模式中最简单使用的模式
2、简单工厂模式：定义了一个创建对象的类，由这个类封装实例化对象的行为（代码）
3、在软件开发中，当我们会用到大量的创建某种、某类或者某批对象时，就会使用到工厂模式。

public interface Shape {
    void draw();
}
​
public class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("绘制一个圆形");
    }
}
​
public class Rectangle implements Shape {
    @Override
    public void draw() {
        System.out.println("绘制一个矩形");
    }
}
​
public class Square implements Shape {
    @Override
    public void draw() {
        System.out.println("绘制一个正方形");
    }
}
​
​
public class ShapeFactory {
    public static Shape createShape(String type) {
        if (type.equalsIgnoreCase("circle")) {
            return new Circle();
        } else if (type.equalsIgnoreCase("rectangle")) {
            return new Rectangle();
        } else if (type.equalsIgnoreCase("square")) {
            return new Square();
        }
        return null;
    }
}
​
​
public class Main {
    public static void main(String[] args) {
        Shape circle = ShapeFactory.createShape("circle");
        circle.draw();  // 输出：绘制一个圆形
​
        Shape rectangle = ShapeFactory.createShape("rectangle");
        rectangle.draw();  // 输出：绘制一个矩形
​
        Shape square = ShapeFactory.createShape("square");
        square.draw();  // 输出：绘制一个正方形
    }
}

总结：

优点：
​1、简单工厂模式实现了对象创建和对象使用的分离，客户端只需知道产品的类型，无需关心产品的创建细节。
2、可以通过工厂方法来集中控制对象的创建，便于统一管理和维护。
3、客户端可以直接通过工厂类来创建对象，简化了客户端代码，提高了代码的可读性和可维护性。
4、简单工厂模式实现了依赖倒置原则，客户端只需要依赖工厂类，而不需要依赖具体的产品类，降低了耦合
​
​缺点：
​1、当需要新增产品时，需要修改工厂类的代码，违反了开闭原则。
2、工厂类的职责较重，包括对象的创建和选择逻辑，违反了单一职责原则。
3、对象的创建过程集中在一个工厂类中，如果系统中的产品过多或产品创建过程复杂，会导致工厂类臃肿，不利于扩展和维护。
4、简单工厂模式会导致客户端与工厂类之间的耦合度增加，一旦工厂类出现问题，客户端可能也会受到影响。
​
​总的来说，简单工厂模式适用于对象较少且变化不频繁的场景，但在面对频繁变化的产品类型或产品创建过程复杂的情况下，不太适合使用简单工厂模式。

工厂方法模式

介绍
定义了一个创建对象的抽象方法，由子类决定要实例化的累。工厂方法模式将对象的实例化放到子类。（子类进行生产对象）

// 抽象产品类
interface Product {
    void operation();
}
​
// 具体产品类A
class ConcreteProductA implements Product {
    @Override
    public void operation() {
        System.out.println("ConcreteProductA operation");
    }
}
​
// 具体产品类B
class ConcreteProductB implements Product {
    @Override
    public void operation() {
        System.out.println("ConcreteProductB operation");
    }
}
​
// 工厂接口
interface Factory {
    Product createProduct();
}
​
// 具体工厂A
class ConcreteFactoryA implements Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProductA();
    }
}
​
// 具体工厂B
class ConcreteFactoryB implements Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProductB();
    }
}
​
// 客户端代码
public class Client {
    public static void main(String[] args) {
        Factory factoryA = new ConcreteFactoryA();
        Product productA = factoryA.createProduct();
        productA.operation();
​
        Factory factoryB = new ConcreteFactoryB();
        Product productB = factoryB.createProduct();
        productB.operation();
    }
}

优点：
1、松耦合：工厂方法模式将客户端代码与具体产品类解耦，客户端不需要知道具体产品的类名，只需要知道产品的接口或抽象类即可。这使得系统更容易维护和扩展，因为新增产品时只需添加新的具体产品类和对应的工厂类，而不需要修改现有的客户端代码。 ​
2、可扩展性：由于每个具体产品都有对应的具体工厂，可以轻松地添加新的具体产品类和对应的工厂类，而不会影响现有的代码结构。这使得系统具有很好的可扩展性，符合开闭原则。
3、封装变化：工厂方法模式将对象的创建过程封装到具体的工厂类中，客户端无需关心对象的创建细节，只需通过工厂来获取对象。这样，如果对象的创建过程发生变化，只需修改对应的工厂类，而不会影响客户端代码。 ​

缺点：
1、类的数量增加：工厂方法模式会导致系统中类的数量增加，因为每个具体产品都需要对应一个具体工厂。如果产品种类很多，会导致类的数量剧增，增加了系统的复杂度。
2、增加了系统的抽象性和理解难度：引入了抽象工厂和具体工厂的概念，增加了系统的抽象性，使得系统的理解和学习成本增加。 ​
3、一定程度上增加了开发的复杂度：相对于简单的直接实例化对象来说，工厂方法模式引入了额外的抽象层，增加了开发的复杂度，尤其是对于简单的场景来说可能会显得过于繁琐。 ​

工厂方法模式的优点包括松耦合、可扩展性和封装变化。它将客户端代码与具体产品类解耦，使系统更易于维护和扩展。缺点包括增加类的数量、增加系统的抽象性和理解难度，以及在一定程度上增加了开发的复杂度。在设计时需要权衡利弊，根据具体情况选择是否使用工厂方法模式

抽象工厂模式

介绍：
1、抽象工厂模式：它提供了一个接口，用于创建相关或依赖对象的家族，而无需指定具体类。
-》 说明抽象工厂模式允许客户端使用抽象的接口来创建相关的产品对象，并且不需要知道具体实现
​
2、将工厂抽象成两层，AbsFactory（抽象工厂）和具体实现的工厂子类。我们可以根据创建类型和使用对应的工厂子类，将单个的简单工厂类变成工厂家族，利于代码的维护和扩展

抽象工厂就是有一个总的抽象工厂类，然后有子类去实现这个抽象工厂来实现它，并且为之实现生产产品的方法

定义抽象工厂 PizzaFactory 和抽象产品接口 Pizza 以及原料接口 PizzaIngredient：

// 抽象工厂
interface PizzaFactory {
    Pizza createPizza();
    PizzaIngredient createIngredient();
}
​
// 抽象产品 - 披萨
interface Pizza {
    void prepare();
    void bake();
    void cut();
    void box();
}
​
// 抽象产品 - 原料
interface PizzaIngredient {
    String getIngredient();
}

这里是实现具体的工厂类和产品类：

// 具体工厂类 - 纽约风味披萨工厂
class NYPizzaFactory implements PizzaFactory {
    @Override
    public Pizza createPizza() {
        return new NYStylePizza();
    }
​
    @Override
    public PizzaIngredient createIngredient() {
        return new NYStyleIngredient();
    }
}
​
// 具体工厂类 - 芝加哥风味披萨工厂
class ChicagoPizzaFactory implements PizzaFactory {
    @Override
    public Pizza createPizza() {
        return new ChicagoStylePizza();
    }
​
    @Override
    public PizzaIngredient createIngredient() {
        return new ChicagoStyleIngredient();
    }
}
​
// 具体产品类 - 纽约风味披萨
class NYStylePizza implements Pizza {
    // 省略具体实现
}
​
// 具体产品类 - 芝加哥风味披萨
class ChicagoStylePizza implements Pizza {
    // 省略具体实现
}
​
// 具体产品类 - 纽约风味原料
class NYStyleIngredient implements PizzaIngredient {
    @Override
    public String getIngredient() {
        return "NY style ingredient";
    }
}
​
// 具体产品类 - 芝加哥风味原料
class ChicagoStyleIngredient implements PizzaIngredient {
    @Override
    public String getIngredient() {
        return "Chicago style ingredient";
    }
}
​
// 客户端代码
public class PizzaStore {
    private PizzaFactory factory;
​
    public PizzaStore(PizzaFactory factory) {
        this.factory = factory;
    }
​
    public Pizza orderPizza() {
        Pizza pizza = factory.createPizza();
        PizzaIngredient ingredient = factory.createIngredient();
        System.out.println("Preparing " + pizza.getClass().getSimpleName() + " with " + ingredient.getIngredient());
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
        return pizza;
    }
​
    public static void main(String[] args) {
        PizzaStore nyStore = new PizzaStore(new NYPizzaFactory());
        nyStore.orderPizza();
​
        PizzaStore chicagoStore = new PizzaStore(new ChicagoPizzaFactory());
        chicagoStore.orderPizza();
    }
}

抽象工厂模式是一种创建型设计模式，它提供了一种封装一组相关对象创建的方式。
​
优点：
抽象工厂模式通过解耦具体类的创建与客户端代码，确保产品系列相互匹配，并容易交换不同产品系列
​
缺点：
​增加新的产品族或产品等级结构可能导致抽象工厂接口和具体工厂类的修改，以及需要修改所有客户端代码。

小结

工厂模式在JDK-Calendar应用的源码：使用到了简单工厂模式
1、工厂模式的目的：
将实例化对象的代码提取出来，放到一个类中统一管理和维护，达到和主项目的依赖关系的解耦。从而提高项目的扩展和维护性。
2、三种工厂模式

• 简单工厂模式：由一个工厂类根据客户端请求创建产品，适用于产品种类较少且变化不频繁的情况。
• 工厂方法模式：定义创建对象接口，延迟具体创建到子类实现，允许系统引入新产品而不修改客户端代码。
• 抽象工厂模式：提供接口创建相关对象，通过具体工厂创建产品族，适用于创建相互关联或依赖对象的情况。