工厂模式

在面向对象编程中，继承是一个基本概念，它与多态共同构成了类的父子继承关系。Car对象可以被当作Vehicle对象处理，Truck对象也可以被当作Vehicle对象处理。一方面，这种抽象方式使得同一段代码能为Car和Truck对象提供同样的处理操作，使代码更加简洁；另一方面，如果要扩展新的Vehicle对象类型，比如Bike，不再需要修改代码，只需添加新的类即可。

类应该保持对扩展的开放和对修改的关闭（开闭原则）；
每个类应该只有一个发生变化的原因（单一职责原则）。

工厂模式用于实现逻辑的封装，并通过公共的接口提供对象的实例化服务，在添加新的类时只需要做少量的修改。

1.静态工厂模式

public class VehicleFactory {
    public enum VehicleType {
        Bike, Car, Truck;
    }
    public static Vehicle create(VehicleType type) {
        if (type.equals(VehicleType.Bike))
            return new Bike();
        if (type.equals(VehicleType.Car))
            return new Car();
        if (type.equals(VehicleType.Truck))
            return new Truck();
    }
}

增加一个新的Vehicle类时，需要对VehicleFactory类进行修改，这样就打破了开闭原则。

2.改进上述的简单工厂模式，使用newInstance方法进行类注册的简单工厂模式

public class VehicleFactory {
    private Map<String, Vehicle> registeredProducts = new HashMap<>();

    public void registerVehicle(String vehicleId, Vehicle vehicle) {
        registeredProducts.put(vehicleId, vehicle);
    }

    public Vehicle createVehicle(String vehicleId) {
        return registeredProducts.get(vehicleId).newInstance();
    }
}

abstract public class Vehicle {
    abstract public Vehicle newInstance();

    public void dosomething() {
        System.out.println("Vehicle");
    }
}

public class Car extends Vehicle {
    @Override
    public Car newInstance() {
        return new Car();
    }

    @Override
    public void dosomething() {
        System.out.println("Car");
    }
}

public class Truck extends Vehicle{
    @Override
    public Truck newInstance() {
        return new Truck();
    }

    @Override
    public void dosomething() {
        System.out.println("Truck");
    }
}

public class test {
    public static void main(String[] args) {
        VehicleFactory vehicleFactory = new VehicleFactory();
        vehicleFactory.registerVehicle("Car", new Car());
        vehicleFactory.registerVehicle("Truck", new Truck());

        Vehicle vehicle = vehicleFactory.createVehicle("Car");
        vehicle.dosomething();
        Vehicle vehicle1 = vehicleFactory.createVehicle("Truck");
        vehicle1.dosomething();
    }
}

3.工厂方法模式
工厂方法模式是在静态工厂模式上的改进。工厂类被抽象化，用于实例化特定产品类的代码被转移到实现抽象方法的子类中。

abstract public class Vehicle {
    public void dosomthing() {
        System.out.println("vehicle");
    }
}

public class Car extends Vehicle {
    @Override
    public void dosomthing() {
        System.out.println("car");
    }
}

public class Truck extends Vehicle{
    @Override
    public void dosomthing() {
        System.out.println("truck");
    }
}

abstract public class VehicleFactory {
    public abstract Vehicle createVehicle(String item);

    public Vehicle orderVehicle(String type) {
        Vehicle vehicle = createVehicle(type);
        return vehicle;
    }
}

public class Factory extends VehicleFactory {
    @Override
    public Vehicle createVehicle(String item) {
        if (item.equals("Car"))
            return new Car();
        if (item.equals("Truck"))
            return new Truck();
        return null;
    }
}

public class test {
    public static void main(String[] args) {
        VehicleFactory factory = new Factory();
        factory.orderVehicle("Car").dosomthing();
        factory.orderVehicle("Truck").dosomthing();
    }
}

注意：工厂类中并不包含任何创建新实例的代码。