工厂模式与抽象工厂模式

如有错误或有补充，以及任何的改进意见，请在评论区留下您的高见

工厂模式

工厂模式是一种创建型设计模式。在工厂模式中，类的实例化过程通常是通过一个专门的工厂类来完成的，而不是直接在客户端代码中进行的。这样可以提供更好的封装，使得客户端代码与具体产品的实现解耦，增加代码的灵活性和可维护性。

优点

封装性：客户端代码不再需要知道所创建对象的详细信息，只需要与工厂接口进行交互即可。

灵活性：工厂模式使得系统更加灵活，可以在不修改客户端代码的情况下更换或添加新产品。

可扩展性：通过使用工厂模式，当需要添加新产品时，只需要扩展工厂类，而不需要修改客户端代码。

基本结构

抽象产品（Abstract Product）：这是要创建的对象的抽象接口。

具体产品（Concrete Product）：实现了抽象产品接口的具体类。

具体工厂（Concrete Factory）：负责创建具体产品对象。

应用场景

当一个类不知道它所必须创建对象的类时：例如，你可能需要根据输入参数的不同来创建不同的对象。

当一个类希望其子类决定它所创建的对象时：例如，你希望提供一种方法让子类来自定义对象的创建过程。

当一个类希望通过子类来指定它所创建的对象时：在这种情况下，你可以将"创建对象"的职责委托给子类，而不是直接在父类中完成。

示例

假设我们有一个场景，其中需要创建不同的小动物，包括小狗，小猫。此时就可以使用工厂模式。

Animal.java

public interface Animal {
    void eat();
}

AnimalFactroy.java

public class AnimalFactory {
    public Animal getAnimal(String name) {
        if  (name == null){
            return null;
        }

        // 根据不同的输入返回不同对象
        if ("dog".equals(name)) {
            return new Dog();
        } else if ("cat".equals(name)) {
            return new Cat();
        }
        return null;
    }
}

Cat.java

public class Cat implements Animal{
    @Override
    public void eat() {
        System.out.println("吃鱼");   
    }
}

Dog.java

public class Dog implements Animal{
    @Override
    public void eat() {
        System.out.println("吃骨头");
    }
}

Demo.java

public class Demo {
    public static void main(String[] args) {
        AnimalFactory animalFactory = new AnimalFactory();
        Cat cat = (Cat) animalFactory.getAnimal("cat");
        cat.eat();

        Animal dog = animalFactory.getAnimal("dog");
        dog.eat();
    }
}

运行Demo.java输出如下

吃鱼

吃骨头

抽象工厂模式

优点

封装性：客户端代码不再需要知道所创建对象的详细信息，只需要与抽象工厂接口进行交互即可。

灵活性：通过使用抽象工厂模式，可以在不修改客户端代码的情况下更换或添加新产品族。

多态性：客户端代码可以使用同一个接口来创建不同类型的产品对象，增强了代码的复用性。

基本结构

抽象产品（Abstract Product）：这是要创建的对象的抽象接口。

具体产品（Concrete Product）：实现了抽象产品接口的具体类。

抽象工厂（Abstract Factory）：创建产品的工厂的抽象接口。

具体工厂（Concrete Factory）：实现了抽象工厂的类，负责创建具体产品对象。

应用场景

当一个系统中有多个产品族，并且希望客户端代码使用同一个接口来创建不同产品族的对象时：使用抽象工厂模式可以将不同产品族的创建逻辑封装在各自的具体工厂中，使得客户端代码与具体产品实现解耦。

当希望在不修改客户端代码的情况下更换或添加新产品族时：通过扩展具体工厂类来添加新产品族，而不需要修改客户端代码。

当希望对一个系统中的多个产品族进行独立配置时：使用抽象工厂模式可以将配置逻辑集中到具体工厂中，使得客户端代码更加简洁。

示例

我们有不同的类Object需要生成，于是我们把工厂也抽象出来，为每一个类设置不同的工厂，再让这些工厂去继承同一个接口。

Total.java

public class Total {
    public static void main(String[] args) {
        com.hacoj.abstract_factory_pattern.PatternFactory patternFactory = (com.hacoj.abstract_factory_pattern.PatternFactory) com.hacoj.abstract_factory_pattern.FactoryProducer.getFactory("Pattern");
        com.hacoj.abstract_factory_pattern.ColorFactory colorFactory = (com.hacoj.abstract_factory_pattern.ColorFactory) com.hacoj.abstract_factory_pattern.FactoryProducer.getFactory("Color");

        com.hacoj.abstract_factory_pattern.Pattern circle = patternFactory.getPattern("circle");
        com.hacoj.abstract_factory_pattern.Pattern rectangle = patternFactory.getPattern("rectangle");

        com.hacoj.abstract_factory_pattern.Color red = colorFactory.getColor("red");
        com.hacoj.abstract_factory_pattern.Color blue = colorFactory.getColor("blue");

        circle.show();
        rectangle.show();

        red.show();
        blue.show();
    }
}

class FactoryProducer {
    public static com.hacoj.abstract_factory_pattern.AbstractFactory getFactory(String name) {
        if (name==null) {
            return null;
        }

        if ("Pattern".equals(name)) {
            return new PatternFactory();
        } else if ("Color".equals(name)) {
            return new com.hacoj.abstract_factory_pattern.ColorFactory();
        } else {
            System.out.println("没有对应的厂子");
            return null;
        }
    }
}


interface AbstractFactory {

}

interface Pattern {
    void show();
}

interface Color {
    void show();
}

class Circle implements Pattern {
    @Override
    public void show() {
        System.out.println("这是圆形");
    }
}

class Blue implements Color {
    @Override
    public void show() {
        System.out.println("这是蓝色");
    }
}

class Rectangle implements com.hacoj.abstract_factory_pattern.Pattern {
    @Override
    public void show() {
        System.out.println("这是方形");
    }
}

class Red implements com.hacoj.abstract_factory_pattern.Color {
    @Override
    public void show() {
        System.out.println("这是红色");
    }
}

class ColorFactory implements com.hacoj.abstract_factory_pattern.AbstractFactory {
    public com.hacoj.abstract_factory_pattern.Color getColor(String name) {
        if (name==null){
            return null;
        }

        if ("red".equals(name)){
            return new Red();
        } else if ("blue".equals(name)) {
            return new com.hacoj.abstract_factory_pattern.Blue();
        } else {
            System.out.println("Invalid color");
            return null;
        }
    }
}

class PatternFactory implements com.hacoj.abstract_factory_pattern.AbstractFactory {
    public com.hacoj.abstract_factory_pattern.Pattern getPattern(String name) {
        if (name == null) {
            return null;
        }

        if ("rectangle".equals(name)) {
            return new Rectangle();
        } else if ("circle".equals(name)) {
            return new com.hacoj.abstract_factory_pattern.Circle();
        } else {
            System.out.println("Invalid pattern");
            return null;
        }
    }
}

区别

普通工厂模式仅用于创建单个对象，而抽象工厂模式可以创建一类对象。抽象工厂模式更灵活，可维护性和可扩展性更强，适用于多个产品等级结构。