java设计模式–三种工厂模式详解

Java 设计模式：三种工厂模式详解

工厂模式是Java中常见的一种设计模式，用来解决对象创建过程中的一些问题。根据具体的需求和使用场景，工厂模式还可以进一步细分为三种——简单工厂模式、工厂方法模式和抽象工厂模式。

本文将详细讲解三种工厂模式的原理、特点、适用场景以及代码实现等方面的内容，希望对Java初学者有所帮助。

简单工厂模式

原理

在简单工厂模式中，创建对象的工作由工厂类来完成，客户端只需要给出需要创建对象的类型，工厂类就可以根据类型进行创建。因此，简单工厂模式将对象的创建和使用分离开来，降低了客户端与具体对象之间的耦合度。

特点

• 客户端只需要知道所需产品的名称即可，无需了解具体的实现。
• 工厂类负责对象的创建和管理。
• 简单工厂模式适用于工厂类负责业务较少，对象简单创建流程且客户端只需要知道产品名称的情况下。

适用场景

• 希望封装对象创建的细节，降低耦合度。
• 当一个类有很多子类，而客户端需要根据条件来选择其中一种时，可以考虑简单工厂模式。
• 当客户端只知道传入的参数，而不知道具体要创建的对象时，可以使用简单工厂模式。

示例

比如在网站注册的过程中，需要获取用户类型并创建对应的用户对象。我们可以使用简单工厂模式来创建这些用户对象。

/**
 * 用户类
 */
public abstract class User {
    public abstract void show();
}

/**
 * 普通用户
 */
public class NormalUser extends User {
    @Override
    public void show() {
        System.out.println("我是普通用户");
    }
}

/**
 * VIP用户
 */
public class VipUser extends User {
    @Override
    public void show() {
        System.out.println("我是VIP用户");
    }
}

/**
 * 用户工厂类
 */
public class UserFactory {
    public static User createUser(String userType) {
        if ("normalUser".equals(userType)) {
            return new NormalUser();
        } else if ("vipUser".equals(userType)) {
            return new VipUser();
        } else {
            throw new RuntimeException("unsupported user type");
        }
    }
}

/**
 * 客户端代码
 */
public class Client {
    public static void main(String[] args) {
        User normalUser = UserFactory.createUser("normalUser");
        normalUser.show();

        User vipUser = UserFactory.createUser("vipUser");
        vipUser.show();
    }
}

输出结果：

我是普通用户
我是VIP用户

工厂方法模式

原理

工厂方法模式是在简单工厂模式的基础上进一步发展而来的一种模式，每个具体产品对应一个具体的工厂类，将工厂类的创建过程也进行了解耦。客户端只需要根据需要的具体产品对应的具体工厂类来进行实例化操作。

特点

• 将对象的创建和使用分离开来，降低了客户端和具体产品的耦合度。
• 每个具体产品都对应一个具体的工厂类，扩展性高。

适用场景

• 当对象复杂创建流程，需要多个工厂类进行配合创建时，可以使用工厂方法模式。
• 当客户端只需要知道要创建的产品即可，不需要知道具体的实现时，可以考虑使用工厂方法模式。

示例

比如在网站中，有多个用户类型需要创建，我们可以使用工厂方法模式来创建这些用户类型的对象。

/**
 * 用户类
 */
public abstract class User {
    public abstract void show();
}

/**
 * 普通用户
 */
public class NormalUser extends User {
    @Override
    public void show() {
        System.out.println("我是普通用户");
    }
}

/**
 * VIP用户
 */
public class VipUser extends User {
    @Override
    public void show() {
        System.out.println("我是VIP用户");
    }
}

/**
 * 用户工厂接口
 */
public interface UserFactory {
    User createUser();
}

/**
 * 普通用户工厂
 */
public class NormalUserFactory implements UserFactory {
    @Override
    public User createUser() {
        return new NormalUser();
    }
}

/**
 * VIP用户工厂
 */
public class VipUserFactory implements UserFactory {
    @Override
    public User createUser() {
        return new VipUser();
    }
}

/**
 * 客户端代码
 */
public class Client {
    public static void main(String[] args) {
        UserFactory normalUserFactory = new NormalUserFactory();
        User normalUser = normalUserFactory.createUser();
        normalUser.show();

        UserFactory vipUserFactory = new VipUserFactory();
        User vipUser = vipUserFactory.createUser();
        vipUser.show();
    }
}

输出结果：

我是普通用户
我是VIP用户

抽象工厂模式

原理

抽象工厂模式提供了一个接口用来创建一系列相关或相互依赖的对象，而不需要指定它们的具体类。抽象工厂模式同样可以通过工厂方法模式来对工厂进行抽象，最终达到创建对象和使用对象相分离的目的。

特点

• 可以创建一系列相关的产品对象。
• 具备良好的扩展性，当需要新增产品对象时，只需要添加一个工厂类即可。

适用场景

• 当有多个系列产品需要创建时，可以使用抽象工厂模式。
• 当需要各个系列产品进行组合时，可以考虑使用抽象工厂模式。

示例

在一个网站中，有多个系列的用户和订单需要创建，我们可以使用抽象工厂模式来进行创建。

/**
 * 用户类
 */
public abstract class User {
    public abstract void show();
}

/**
 * 订单类
 */
public abstract class Order {
    public abstract void show();
}

/**
 * 普通用户
 */
public class NormalUser extends User {
    @Override
    public void show() {
        System.out.println("我是普通用户");
    }
}

/**
 * VIP用户
 */
public class VipUser extends User {
    @Override
    public void show() {
        System.out.println("我是VIP用户");
    }
}

/**
 * 普通订单
 */
public class NormalOrder extends Order {
    @Override
    public void show() {
        System.out.println("我是普通订单");
    }
}

/**
 * VIP订单
 */
public class VipOrder extends Order {
    @Override
    public void show() {
        System.out.println("我是VIP订单");
    }
}

/**
 * 抽象工厂接口
 */
public interface Factory {
    User createUser();
    Order createOrder();
}

/**
 * 普通用户工厂
 */
public class NormalFactory implements Factory {
    @Override
    public User createUser() {
        return new NormalUser();
    }

    @Override
    public Order createOrder() {
        return new NormalOrder();
    }
}

/**
 * VIP用户工厂
 */
public class VipFactory implements Factory {
    @Override
    public User createUser() {
        return new VipUser();
    }

    @Override
    public Order createOrder() {
        return new VipOrder();
    }
}

/**
 * 客户端代码
 */
public class Client {
    public static void main(String[] args) {
        Factory normalFactory = new NormalFactory();
        User normalUser = normalFactory.createUser();
        normalUser.show();
        Order normalOrder = normalFactory.createOrder();
        normalOrder.show();

        Factory vipFactory = new VipFactory();
        User vipUser = vipFactory.createUser();
        vipUser.show();
        Order vipOrder = vipFactory.createOrder();
        vipOrder.show();
    }
}

输出结果：

我是普通用户
我是普通订单
我是VIP用户
我是VIP订单