工厂模式

简单工厂模式

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

代码演示

车辆（抽象类）

/**
 * 车辆（抽象类）
 */
public abstract class Vehicle {
    abstract public void run();
}

小汽车具体类

/**
 * 小汽车具体类
 */
public class Car extends Vehicle {
    @Override
    public void run() {
        System.out.println("小汽车在公路上呼啸而过");
    }
}

自行车具体类

/**
 * 自行车具体类
 */
public class Bike extends Vehicle {
    @Override
    public void run() {
        System.out.println("自行车跑的慢");
    }
}

车辆类型枚举

public enum VehicleType {
    Bike,Car
}

车辆工厂类

/**
 * 车辆工厂类
 */
public class VehicleFactory {
    
    /**
     * 静态工厂模式
     *
     * 工厂只负责Vehicle类的实例化，符合单一职责原则。
     * 用户只调用Vehicle接口，减少耦合，符合依赖倒置原则。
     * @param type
     * @return
     */
    public static Vehicle create(VehicleType type){

        if (type.equals(VehicleType.Bike)){
            return new Bike();
        }
        if (type.equals(VehicleType.Car)){
            return new Car();
        }
        else return null;
    }
}

客户端

public class Client {
    public static void main(String[] args) throws Exception {

        Vehicle bike = VehicleFactory.create(VehicleType.Bike);
        bike.run();//自行车跑的慢

        Vehicle car = VehicleFactory.create(VehicleType.Car);
        car.run();//小汽车在公路上呼啸而过
    }
}

工厂类逻辑简单，只负责Vehicle类的实例化，符合单一职责原则；

用户只调用Vehicle接口，减少耦合，符合依赖倒置的原则；

但是当增加一种新类的时候，需要对VehicleFactory工厂类进行修改，这样就打破了开闭原

则。解决这个问题可以在每个产品类中添加newInstance()方法来解决，该方法返回与自身

类型相同的新实例。

工厂方法模式

工程方法模式是在静态工厂模式上的改进，工厂类被实例化。用于实例化特定产品类的代码被转移到实现抽象方法的子类中。这样就不需要修改就可以扩展工厂类。

代码演示

车辆（抽象类）

/**
 * 车辆（抽象类）
 */
public abstract class Vehicle {

    /**
     * 车辆运行
     */
    public abstract void running();
}

汽车类

/**
 * 汽车类
 */
public class Car extends Vehicle {

    @Override
    public void running() {
        System.out.println("小汽车开始运行");
    }
}

卡车类

/**
 * 卡车类
 */
public class Truck extends Vehicle {
    @Override
    public void running() {
        System.out.println("卡车开始运行");
    }
}

车辆抽象工厂

/**
 * 车辆抽象工厂
 */
public abstract class VehicleFactory {
    /**
     * 创建车辆
     * @return
     */
    protected abstract Vehicle createVehicle();

}

汽车具体工厂类

/**
 * 汽车具体工厂类
 */
public class CarFactory extends VehicleFactory {

    @Override
    protected Vehicle createVehicle() {
        return new Car();
    }


}

卡车工厂类

/**
 * 卡车工厂类
 */
public class TruckFactory extends VehicleFactory {
    @Override
    protected Vehicle createVehicle() {
        return new Truck();
    }
}

客户端测试

public class Client {
    public static void main(String[] args) {

        VehicleFactory carFactory = new CarFactory();
        Vehicle car = carFactory.createVehicle();
        car.running();

        VehicleFactory truckFactory = new TruckFactory();
        Vehicle truck = truckFactory.createVehicle();
        truck.running();
    }
}

抽象工厂模式

抽象工厂模式是简单工厂模式的扩展版本。

它不再是创建单一类型的对象，而是创建一系列相关的对象。

如果说工厂方法中只包含一个抽象产品类，那么抽象工厂模式中则包含多个抽象产品类。

车辆抽象类

/**
 * 车辆抽象类
 */
public abstract class Vehicle {
    String color;
    //abstract Vehicle class
    public void testVehicle() {
        // implementation here
    }

    public void setColor(String color) {
        this.color=color;
    }

    public abstract void running();
}

汽车抽象类

/**
 * 汽车抽象类
 */
public abstract class Car extends Vehicle {
}

小轿车具体类

/**
 * 小轿车具体类
 */
public class SedanCar extends Car {
    @Override
    public void running() {
        System.out.println("小轿车开始跑");
    }
}

跑车具体类

/**
 * 跑车具体类
 */
public class SportCar extends Car {
    @Override
    public void running() {
        System.out.println("跑车开始飞驰");
    }
}

卡车抽象类

/**
 * 卡车抽象类
 */
public abstract class Truck extends Vehicle {
}

小卡车具体类

/**
 * 小卡车具体类
 */
public class SmallTruck extends Truck {
    @Override
    public void running() {
        System.out.println("小卡车慢慢的跑");
    }
}

大卡车具体类

/**
 * 大卡车具体类
 */
public class LargeTruck extends Truck {
    @Override
    public void running() {
        System.out.println("大卡车平稳的跑");
    }
}

抽象工厂类

/**
 * 抽象工厂类
 */
public abstract class VehicleFactory {
    protected abstract Vehicle createVehicle(String item);

    public Vehicle orderVehicle(String size, String color)
    {
        Vehicle vehicle = createVehicle(size);

        vehicle.testVehicle();
        vehicle.setColor(color);

        return vehicle;
    }
}

汽车工厂

/**
 * 汽车工厂
 */
public class CarFactory extends VehicleFactory {
    @Override
    protected Vehicle createVehicle(String size) {

        if (size.equals("small"))
            return new SportCar();
        else if (size.equals("large"))
            return new SedanCar();

        return null;
    }
}

卡车工厂

/**
 * 卡车工厂
 */
public class TruckFactory extends VehicleFactory {
    @Override
    protected Vehicle createVehicle(String size) {

        if (size.equals("small"))
            return new SmallTruck();
        else if (size.equals("large"))
            return new LargeTruck();

        return null;
    }
}

客户端测试

public class Client {
    public static void main (String s[]) {
        VehicleFactory carFactory = new CarFactory();
        Vehicle car = carFactory.orderVehicle("small", "blue");
        System.out.println("car.color:" + car.color);
        car.running();

        VehicleFactory truckFactory = new TruckFactory();
        Vehicle truck = truckFactory.orderVehicle("large", "yellow");
        System.out.println("truck.color:" + truck.color);
        truck.running();
    }
}