23种设计模式-工厂模式

工厂模式是一种创建型设计模式，它提供了一种方法来创建对象，而不需要在代码中显式地指定对象的具体类。在工厂模式中，我们创建一个工厂类，这个工厂类负责创建对象，并且将对象的创建过程封装起来。

工厂模式的实现

工厂模式有三种常见的实现方式：简单工厂模式、工厂方法模式和抽象工厂模式。简单工厂模式是最基础的工厂模式，它将对象的创建逻辑封装在一个工厂类中，根据不同的参数来创建不同的对象。工厂方法模式则是将工厂类抽象成一个接口，每个具体的工厂类都实现这个接口来创建自己特定的对象。而抽象工厂模式则是针对产品族的创建，每个具体的工厂类可以创建一系列相关的产品。

1.简单工厂模式

简单工厂模式是工厂模式中最基础的一种实现方式，它通过一个工厂类来封装对象的创建过程，根据不同的参数返回不同的对象实例。下面是一个简单工厂模式的Java实现示例：

首先，我们定义一个抽象的产品接口，这里以图形为例：

public interface Shape {
    void draw();
}

然后，我们定义具体的产品类，这里定义两个实现类，分别是圆形和矩形：

public class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("Draw a circle.");
    }
}

public class Rectangle implements Shape {
    @Override
    public void draw() {
        System.out.println("Draw a rectangle.");
    }
}

接下来，我们定义一个工厂类，根据传入的参数不同来创建不同的对象：

public class ShapeFactory {
    public static Shape getShape(String shapeType) {
        if (shapeType == null) {
            return null;
        }

        if (shapeType.equalsIgnoreCase("CIRCLE")) {
            return new Circle();
        } else if (shapeType.equalsIgnoreCase("RECTANGLE")) {
            return new Rectangle();
        }

        return null;
    }
}

在这个工厂类中，我们定义了一个静态方法 getShape()，根据传入的参数不同，创建不同的对象并返回。

最后，我们可以使用这个工厂类来创建对象：

public class Main {
    public static void main(String[] args) {
        Shape circle = ShapeFactory.getShape("CIRCLE");
        circle.draw();

        Shape rectangle = ShapeFactory.getShape("RECTANGLE");
        rectangle.draw();
    }
}

2.工厂方法模式

public interface Product {
    void use();
}

public interface Factory {
    Product createProduct();
}

public class ConcreteProductA implements Product {
    @Override
    public void use() {
        System.out.println("使用产品 A");
    }
}

public class ConcreteProductB implements Product {
    @Override
    public void use() {
        System.out.println("使用产品 B");
    }
}

最后，我们定义两个具体的工厂类 ConcreteFactoryA 和 ConcreteFactoryB，它们分别负责创建产品 A 和产品 B 的对象：

public class ConcreteFactoryA implements Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProductA();
    }
}
最后，我们定义两个具体的工厂类 `ConcreteFactoryA` 和 `ConcreteFactoryB`，它们分别负责创建产品 A 和产品 B 的对象：
public class ConcreteFactoryB implements Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProductB();
    }
}

这样，我们就完成了工厂方法模式的 Java 实现。下面是一个使用工厂方法模式的示例：

public class Client {
    public static void main(String[] args) {
        Factory factoryA = new ConcreteFactoryA();
        Product productA = factoryA.createProduct();
        productA.use();

        Factory factoryB = new ConcreteFactoryB();
        Product productB = factoryB.createProduct();
        productB.use();
    }
}

3.抽象工厂模式

首先，我们定义汽车和手机的抽象产品接口：

public interface Car {
    void drive();
}

public interface Phone {
    void call();
}

然后，我们定义抽象工厂接口，用于创建一组相关的产品：

public interface AbstractFactory {
    Car createCar();
    Phone createPhone();
}

接下来，我们实现两个具体工厂类：SedanFactory和SmartphoneFactory，用于创建Sedan和Smartphone族的具体产品：

public class SedanFactory implements AbstractFactory {
    @Override
    public Car createCar() {
        return new Sedan();
    }

    @Override
    public Phone createPhone() {
        return new OldPhone();
    }
}

public class SmartphoneFactory implements AbstractFactory {
    @Override
    public Car createCar() {
        return new SUV();
    }

    @Override
    public Phone createPhone() {
        return new Smartphone();
    }
}

最后，我们实现四个具体产品类：Sedan、SUV、Smartphone和OldPhone：

public class Sedan implements Car {
    @Override
    public void drive() {
        System.out.println("Driving Sedan");
    }
}

public class SUV implements Car {
    @Override
    public void drive() {
        System.out.println("Driving SUV");
    }
}

public class Smartphone implements Phone {
    @Override
    public void call() {
        System.out.println("Making a call with Smartphone");
    }
}

public class OldPhone implements Phone {
    @Override
    public void call() {
        System.out.println("Making a call with Old Phone");
    }
}

现在，我们可以使用抽象工厂模式创建不同族的产品：

public class Client {
    public static void main(String[] args) {
        AbstractFactory sedanFactory = new SedanFactory();
        Car sedan = sedanFactory.createCar();
        sedan.drive();
        Phone oldPhone = sedanFactory.createPhone();
        oldPhone.call();

        AbstractFactory smartphoneFactory = new SmartphoneFactory();
        Car suv = smartphoneFactory.createCar();
        suv.drive();
        Phone smartphone = smartphoneFactory.createPhone();
        smartphone.call();
    }
}

模式名称	描述	优点	缺点
简单工厂模式	通过一个工厂类创建不同类型的对象，客户端不需要知道具体实现类	简单易懂，能够有效降低代码耦合度，适合创建简单对象	不利于扩展，增加新产品需要修改工厂类的代码，违反了开放封闭原则
工厂方法模式	定义一个创建对象的接口，但由子类决定要实例化的类是哪一个，客户端只需知道创建产品的工厂即可	有良好的扩展性，支持增加新产品的同时，不会修改原有代码	类的数量较多，增加了代码复杂度
抽象工厂模式	提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类	能够有效降低代码耦合度，支持多种产品族的创建	增加新产品族需要修改抽象工厂和所有具体工厂的代码，违反了开放封闭原则，增加了系统的抽象性和理解难度

总的来说，工厂模式是一种非常有用的设计模式，可以提高代码的可读性、可维护性和灵活性。如果你正在编写一个需要大量创建对象的程序，那么工厂模式是一个值得考虑的选择。