工厂模式的三重境界

2023-10-25 00:27:25

工厂模式是一种常用的设计模式，用于创建指定类的实例。在不使用设计模式的时候，我们是怎么创建类的实例的呢？别多想，这个问题没坑，就是我们写代码时直接用 new 。

public class MyClass {

    public static void main(String[] args) {
        // 创建一个 MyClass 的实例
        MyClass myClass = new MyClass();

        // 使用 MyClass 的方法
        myClass.doSomething();
    }

    public void doSomething() {
        System.out.println("Hello, world!");
    }
}

这种创建类的实例的方式很简单，也很直接，但是它有一个缺点，那就是当我们需要创建一个新类的实例时，我们需要修改代码。例如，如果我们想创建一个子类 MySubClass，我们需要修改 main 方法，将 MyClass 换成 MySubClass。

public class MyClass {

    public static void main(String[] args) {
        // 创建一个 MySubClass 的实例
        MySubClass mySubClass = new MySubClass();

        // 使用 MySubClass 的方法
        mySubClass.doSomething();
    }

    public void doSomething() {
        System.out.println("Hello, world!");
    }
}

public class MySubClass extends MyClass {

    @Override
    public void doSomething() {
        System.out.println("Hello, sub world!");
    }
}

这种修改代码的方式很麻烦，而且容易出错。为了解决这个问题，我们可以使用工厂模式。

工厂模式是一种设计模式，用于创建指定类的实例。工厂模式的优点是，它将创建类的实例的过程与使用类的实例的过程分离开来。这样，当我们需要创建一个新类的实例时，我们只需要修改工厂类，而不需要修改使用类的实例的代码。

工厂模式有三种境界：

第一重境界：简单工厂模式

简单工厂模式是最简单的工厂模式。它使用一个工厂类来创建指定类的实例。工厂类负责创建类的实例，而使用类的实例的代码只需要调用工厂类的方法即可。

public class MyClassFactory {

    public static MyClass createMyClass() {
        return new MyClass();
    }
}

public class MyClass {

    public static void main(String[] args) {
        // 创建一个 MyClass 的实例
        MyClass myClass = MyClassFactory.createMyClass();

        // 使用 MyClass 的方法
        myClass.doSomething();
    }

    public void doSomething() {
        System.out.println("Hello, world!");
    }
}

简单工厂模式的优点是，它简单易用，而且可以很好地将创建类的实例的过程与使用类的实例的过程分离开来。但是，简单工厂模式也有一个缺点，那就是它不灵活。当我们需要创建新的子类时，我们需要修改工厂类。

第二重境界：工厂方法模式

工厂方法模式比简单工厂模式更灵活。它使用一个工厂接口来创建指定类的实例。工厂接口定义了一个创建类的实例的方法，而具体的工厂类实现这个方法。这样，当我们需要创建新的子类时，我们只需要创建一个新的工厂类，而不需要修改工厂接口。

public interface MyClassFactory {

    MyClass createMyClass();
}

public class MyClassFactoryImpl implements MyClassFactory {

    @Override
    public MyClass createMyClass() {
        return new MyClass();
    }
}

public class MyClass {

    public static void main(String[] args) {
        // 创建一个 MyClass 的实例
        MyClassFactory factory = new MyClassFactoryImpl();
        MyClass myClass = factory.createMyClass();

        // 使用 MyClass 的方法
        myClass.doSomething();
    }

    public void doSomething() {
        System.out.println("Hello, world!");
    }
}

工厂方法模式的优点是，它比简单工厂模式更灵活，而且可以很好地将创建类的实例的过程与使用类的实例的过程分离开来。但是，工厂方法模式也有一个缺点，那就是它需要定义一个工厂接口，这可能会增加代码的复杂性。

第三重境界：抽象工厂模式

抽象工厂模式是工厂模式中最复杂的一种。它使用一个抽象工厂类来创建指定类的实例。抽象工厂类定义了创建一组相关类的实例的方法，而具体的工厂类实现这些方法。这样，当我们需要创建新的子类时，我们只需要创建一个新的工厂类，而不需要修改抽象工厂类。

public interface AbstractFactory {

    MyClass createMyClass();

    MySubClass createMySubClass();
}

public class ConcreteFactory implements AbstractFactory {

    @Override
    public MyClass createMyClass() {
        return new MyClass();
    }

    @Override
    public MySubClass createMySubClass() {
        return new MySubClass();
    }
}

public class MyClass {

    public static void main(String[] args) {
        // 创建一个 MyClass 的实例
        AbstractFactory factory = new ConcreteFactory();
        MyClass myClass = factory.createMyClass();

        // 使用 MyClass 的方法
        myClass.doSomething();

        // 创建一个 MySubClass 的实例
        MySubClass mySubClass = factory.createMySubClass();

        // 使用 MySubClass 的方法
        mySubClass.doSomething();
    }

    public void doSomething() {
        System.out.println("Hello, world!");
    }
}

public class MySubClass extends MyClass {

    @Override
    public void doSomething() {
        System.out.println("Hello, sub world!");
    }
}