设计模式-工厂模式

￡神魔★判官ぃ 2022-05-11 05:50 220阅读 0赞

个人理解，工厂模式的好处有两点

1.初始化实现类的参数，简化实现类的创建，特别是参数多的时候很实用

2.可以对相同类型的类创建进行归类，且容易维护，比如如果某个实现类的创建过程，增加了新的参数需要初始化或者某个初始化参数需要改动，那么只需要修改工厂类中的实例化方法，不需要去修改所有创建这个类的代码。

## 1.简单工厂模式 ##

描述:通过传递参数创建参数对应的实体类，即可根据不同情况创建不同的实现类

实体类    车辆抽象类，单车类和汽车类继承车辆类

/**
     * 车辆
     * */
    public abstract class Vehicle {
    
        /**
         * 来源
         * */
        protected String origin;
    
        /**
         * 轮子数
         * */
        protected int wheelSum;
    
        /**
         * 描述
         * */
        public abstract void desc();
    }
    
    /**
     * 单车
     * */
    public class Bike extends Vehicle {
    
        public Bike(int wheelSum){
            this.wheelSum = wheelSum;
        }
    
        public Bike(int wheelSum,String origin){
            this.wheelSum = wheelSum;
            this.origin = origin;
        }
    
        @Override
        public void desc() {
            Optional.ofNullable(origin).ifPresent(bikeOrigin ->
                System.out.println("我是单车 我是"+bikeOrigin+"制造")
            );
            System.out.println("我是单车 我有"+wheelSum+"个轮子");
        }
    }
    
    
    /**
     * 汽车
     * */
    public class Car extends Vehicle {
    
        public Car(int wheelSum){
            this.wheelSum = wheelSum;
        }
    
        public Car(int wheelSum,String origin){
            this.wheelSum = wheelSum;
            this.origin = origin;
        }
    
        @Override
        public void desc() {
            Optional.ofNullable(origin).ifPresent(carOrigin ->
                    System.out.println("我是汽车 我是"+carOrigin+"制造")
            );
            System.out.println("我是汽车 我有"+wheelSum+"个轮子");
        }
    }

简单工厂类     设定枚举类型，每次创建根据传递的枚举类型创建对应的实例

public class SimpleFactory{
        /**
         * 车类型枚举
         * */
        public enum VehicleType{
    
            BIKE(1,"单车"),
            CAR(2,"汽车");
    
            private Integer type;
            private String desc;
    
            VehicleType(Integer type,String desc){
                this.type = type;
                this.desc = desc;
            }
        }
    
        /**
         * 创建实例
         * @param vehicleType 车类型
         * */
        public static Vehicle newInstance(VehicleType vehicleType){
            switch (vehicleType){
                case BIKE:
                    return new Bike(2);
                case CAR:
                    return new Car(4);
                default:return null;
            }
        }
    }

main方法

public class Main {
        public static void main(String[] args) {
            Vehicle fruit = SimpleFactory.newInstance(SimpleFruitFactory.VehicleType.BIKE);
            fruit.desc();
        }
    }

运行结果

![70][]

##   2.方法工厂模式 ##

描述:每个创建实例新建一个创建方法

方法工厂 类

public class MultiMethodFactory {
    
        /**
         * 创建单车
         * */
        public static Bike newBikeInstance(){
            return new Bike(2);
        }
    
        /**
         * 创建汽车
         * */
        public static Car newCarInstance(){
            return new Car(4);
        }
    }

main方法

public class Main {
        public static void main(String[] args) {
            Vehicle vehicle = MultiMethodFactory.newBikeInstance();
            vehicle.desc();
        }
    }

相比第一种的优势是，新增创建实例无需改动原有的创建实例逻辑，不会影响到之前的功能，而且参数的接收也更加自由，不同的创建实例方法，可以设定不同的接收参数。

concurrent包下的Executors类创建线程池便是使用这种方式。

##   3.抽象工厂模式 ##

描述:不仅抽象需要创建的类，工厂也进行抽象分类

抽象工厂

/**
     * 车辆工厂
     * */
    public abstract class VehicleFactory {
    
        /**
         * 创建单车
         * */
        public abstract Bike newBikeInstance();
    
        /**
         * 创建汽车
         * */
        public abstract Car newCarInstance();
    }

工厂实现类

/**
     * 中国车辆工厂
     * */
    public class ChinaVehicleFactory extends VehicleFactory {
    
        // 中国
        private static final String CHINA = "china";
    
        @Override
        public Bike newBikeInstance() {
            return new Bike(2,CHINA);
        }
    
        @Override
        public Car newCarInstance() {
            return new Car(4,CHINA);
        }
    }
    
    /**
     * 法国车辆工厂
     * */
    public class FranceVehicleFactory extends VehicleFactory {
    
        // 法国
        private static final String FRANCE = "France";
    
        @Override
        public Bike newBikeInstance() {
            return new Bike(2,FRANCE);
        }
    
        @Override
        public Car newCarInstance() {
            return new Car(4,FRANCE);
        }
    }

main方法

public class Main {
        public static void main(String[] args) {
            Vehicle vehicle = new ChinaVehicleFactory().newBikeInstance();
            vehicle.desc();
        }
    }

![70 1][]

创建的实例根据工厂的不同，车辆的来源属性也不同。

抽象工厂可以在工厂层加多一层分类，只要新增一个类，扩展比较容易，但是也导致对应的类变得更多，更重。

[70]: /images/20220511/03c253d4d89944348259a11fd509be7e.png
[70 1]: /images/20220511/f154c64cdc0c4dc2b8c3a5a211f5a8d9.png