工厂模式

核心是让子类去实现对象的创建过程。

在一个抽象类F中，定义创建对象A的抽象方法，该抽象方法由抽象类F的不同的子类去实现。
如果对象A中的一些操作不确定，只有在创建时才能确定，那么可以把这些操作定义为抽象操作，把对象A转换为抽象对象A。
抽象对象A的抽象操作由抽象类F的子类，在创建抽象对象A的子类时去实现。

定义汽车对象

/**
 * 汽车对象
 */
class Car {
    // 汽车品牌
    private String brand;
    // 汽车各种零部件属性...

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    /**
     * 定义了汽车的组装操作（工厂模式）
     * 这里不确定如何组装，则交给生产该汽车的厂商来决定如何组装
     */
    abstract void compose();

    /**
     * 定义了汽车的检测操作（工厂模式）
     * 这里不确定如何检测，则交给生产该汽车的厂商来决定如何检测
     *
     * @return boolean 是否合格
     */
    abstract boolean check();

    /**
     * 定义了汽车的销毁操作（工厂模式）
     * 这里不确定如何销毁，则交给生产该汽车的厂商来决定如何销毁
     */
    abstract void destroy();
}

定义汽车工厂抽象类

/**
 * 汽车工厂
 * 这里只提供对生产的汽车的入库、组装、检测和销毁操作。
 * 也只定义了汽车的生产操作（抽象方法），具体操作由不同的汽车生产商自己实现。
 */
public abstract class CarFactory {
    // 车库
    private List<Car> cars = new ArrayList<>();

    /**
     * 汽车入库
     *
     * @param car 生产的汽车
     */
    public void save(Car car) {
        cars.add(car);
    }

    /**
     * 组装汽车
     *
     * @param car 要组装的汽车
     */
    public void compose(Car car) {
        car.compose();
    }

    /**
     * 检测汽车质量
     *
     * @param car 要检测的汽车
     * @return boolean 是否合格
     */
    public boolean check(Car car) {
        return car.check();
    }

    /**
     * 销毁不合格汽车
     *
     * @param car 生产的不合格的汽车
     */
    public void destroy(Car car) {
        car.destroy();
        cars.remove(car);
    }

    /**
     * 定义了汽车的生产操作（工厂模式）
     *
     * @return car 生产的汽车
     */
    protected abstract Car createCar(); 
}

定义具体的汽车生产工厂（奔驰）

public class BenzFactory extends CarFactory {
    /**
     * 奔驰工厂实现自己的生产操作
     *
     * @return Car 生产的汽车
     */
    @Override
    protected Car createCar() {
        Car car = new Car(){
            @Override
            void compose() {
                // TODO 实现该汽车的组装操作
            }

            @Override
            boolean check() {
                // TODO 实现该汽车的检测操作
                return getBrand().equals("Benz");
            }
            
            @Override
            void destroy() {
                // TODO 实现该汽车的销毁操作
            }
        };
        car.setBrand("Benz");
        // 组装汽车
        compose(car);
        return car;
    }
}

定义具体的汽车生产工厂（大众）

public class VWFactory extends CarFactory {
    /**
     * 大众工厂实现自己的生产操作
     *
     * @return Car 生产的汽车
     */
    @Override
    protected Car createCar() {
        Car car = new Car(){
            @Override
            void compose() {
                // TODO 实现该汽车的组装操作
            }

            @Override
            boolean check() {
                // TODO 实现该汽车的检测操作
                return getBrand().equals("VW");
            }
            
            @Override
            void destroy() {
                // TODO 实现该汽车的销毁操作
            }
        };
        car.setBrand("VW");
        // 组装汽车
        compose(car);
        return car;
    }
}

测试

public class Main {
    /**
     * 工厂模式：
     * 在一个抽象类F中，定义创建对象A的抽象方法，该抽象方法由抽象类F的不同的子类去实现。
     * 如果对象A中的一些操作不确定，只有在创建时才能确定，那么可以把这些操作定义为抽象操作，把对象A转换为抽象对象A。
     * 抽象对象A的抽象操作由抽象类F的子类，在创建抽象对象A的子类时去实现。
     * <p>
     * 这里的例子是把汽车的生产和检测操作交给具体的汽车生产商去实现
     */
    public static void main(String[] args) {
        // 生产一辆奔驰汽车
        CarFactory benzFactory = new BenzFactory();
        Car benzCar = benzFactory.createCar();
        // 检测汽车是否合格
        if (benzFactory.check(benzCar)) {
            // 汽车合格，入库
            benzFactory.save(benzCar);
        } else {
            // 汽车不合格，销毁
            benzFactory.destroy(benzCar);
        }

        // 生产一辆大众汽车
        CarFactory vwFactory = new VWFactory();
        Car vwCar = vwFactory.createCar();
        // 检测汽车是否合格
        if (benzFactory.check(vwCar)) {
            // 汽车合格，入库
            benzFactory.save(vwCar);
        } else {
            // 汽车不合格，销毁
            benzFactory.destroy(vwCar);
        }
    }
}