【再探】设计模式— 工厂方法、单例及原型模式

 创建型设计模式是处理对象创建的设计模式，主要特点是“将对象的创建与业务代码分离”。一共有五种：工厂方法模式、单例模式、原型模式、抽象工厂模式及建造者模式。

1 单例模式

需求：

1. 在整个系统中只需要一个实例。
2. 管理共享资源，例如数据库连接、配置文件读取等，可以减少资源消耗，提高性能。

1.1 单例模式介绍

确保某个类只有一个实例，自行实例化并且向整个系统提供这个实例。

图 单例模式UML

图 实现单例模式的方式

public class HungryModel {

    private HungryModel() {}

    private final static HungryModel instance = new HungryModel();

    public static HungryModel getInstance() {
        return instance;
    }
}

public class DoubleCheckLocking {

    private DoubleCheckLocking() {}

    private static DoubleCheckLocking instance = null;

    public static DoubleCheckLocking getInstance() {
        if (instance == null) {
            synchronized (DoubleCheckLocking.class) {
                if (instance == null) instance = new DoubleCheckLocking();
            }
        }
        return instance;
    }
}

public class IoDHSingleton {

    private IoDHSingleton() {}

    private static class Holder {
        static final IoDHSingleton instance = new IoDHSingleton();
    }

    public static IoDHSingleton getInstance() {
        return Holder.instance;
    }

}

1.1.1 优缺点

优点：确保一个类在系统中只有一个实例，节约系统资源，提高性能。

缺点：不符合单一职责原则。

2 原型模式

需求：

1. 需要频繁创建属性近似的对象。
2. 需要保持对象在某个时刻的状态。

2.1 原型模式介绍

通过一个已存在的对象克隆出多个一摸一样的对象。

图 原型模式UML

public class Address implements Cloneable{

    public Address() {}

    @Override
    public Address clone() throws CloneNotSupportedException {
        return (Address)super.clone();
    }

    @Override
    public String toString() {
        return "Address(" + Integer.toHexString(hashCode()) + ")";
    }
}

public class User implements Cloneable{

    private List<Address> addressList;

    public void setAddressList(List<Address> addressList) {
        this.addressList = addressList;
    }

    @Override
    public User clone() throws CloneNotSupportedException {
        User clone = (User)super.clone();
        if (addressList != null) {
            List<Address> newList = new ArrayList<>();
            for (Address address : addressList) {
                newList.add(address.clone());
            }
            clone.setAddressList(newList);
        }
        return clone;
    }

    public static void main(String[] args) throws CloneNotSupportedException {
        User user = new User();
        List<Address> addresses = new ArrayList<>();
        addresses.add(new Address());
        addresses.add(new Address());
        user.setAddressList(addresses);

        User clone = user.clone();
        System.out.println(user);
        System.out.println(clone);
    }

    @Override
    public String toString() {
        return "User(" + Integer.toHexString(hashCode()) +"){" +
                "addressList=" + addressList +
                '}';
    }
}

2.1.1 优缺点

优点：1）减少了代码量；2）可读性、可维护性好，耦合度减小。

缺点：2）不符合单一职责原则；2）不符合开闭原则。当对象添加新的属性时可能需要修改代码。

3 工厂方法模式

需求：

1. 将对象创建与业务代码剥离。
2. 让用户在不需要知道具体的类型情况下，创建符合的对象。
3. 隐藏创建这个实例的创建细节。

3.1 工厂方法模式介绍

将对象的创建与自身的业务逻辑分离。定义一个有创建对象接口的工厂，把创建对应产品的细节封装在不同的工厂实现类中。每增加新的产品，只需增加该产品以及对应的工厂实现类。

图 工厂方法模式UML

public class Car {

    private String engine;

    protected Car(String engine) {
        this.engine = engine;
    }
}

public class BMWCar extends Car{
    public BMWCar(String engine) {
        super(engine);
    }
}

public class TeslaCar extends Car{
    public TeslaCar(String engine) {
        super(engine);
    }
}

public interface CarFactory {
    Car buildCar();
}

public class BMWCarFactory implements CarFactory{
    @Override
    public Car buildCar() {
        return new BMWCar("汽油发动机");
    }
}

public class TeslaCarFactory implements CarFactory{
    @Override
    public Car buildCar() {
        return new TeslaCar("电动发动机");
    }
}

public class CarShop {
    public static void main(String[] args) {
        CarFactory carFactory = new BMWCarFactory();
        carFactory.buildCar();

        carFactory = new TeslaCarFactory();
        carFactory.buildCar();
    }
}

3.1.1 优缺点

优点：1）符合单一职责原则，可读性好。2）符合开闭原则，扩展性好。3）符合依赖倒置原则，耦合度降低。

缺点：类的数量增加，增加了系统的复杂性，可能会影响性能。