设计模式之工厂模式

为了帮助更好的理解工厂模式，我们采用汽车生产的例子

1. 工厂模式

建立一个接口，通过实现类，在实现类中进行实例化产品对象。一般实现类称为Factory，从实现类中拿到新对象，就像去工厂中取货一样，我们不自己生产（new）对象，只向工厂进行申请。

2. 分类

• 简单工厂模式
• 工厂方法模式
• 抽象工厂模式（严格来说不算工厂模式，但是我觉得很像）

3. 简单工厂模式

场景1：今天我去找厂长买车，我说要买奥迪，他就造奥迪，我说要买宝马，他就造宝马。反正他厂里生产线都有。

/**
 * 汽车类接口
 * Created by wjj on 2021/1/4
 */
public interface Car {
}

/**
 * 奥迪
 * Created by wjj on 2021/1/4
 */
public class Audi implements Car{
    public Audi() {
        System.out.println("这是一辆奥迪");
   }
}

/**
 * 宝马
 * Created by wjj on 2021/1/4
 */
public class BMW implements Car {
   public  BMW(){
       System.out.println("这是一辆宝马");
   }
}

/**
 * 汽车生产厂
 * Created by wjj on 2021/1/4
 */
public class Factory {
    public static Car CreateCar(String str){
        if("BMW".equals(str)){
            /*
            根据业务场景需要，可以在这里对请求的对象pojo操作
            * */
            return new BMW();
        } else if("Audi".equals(str)){
             /*
            根据业务场景需要，可以在这里对请求的对象pojo操作
            * */
            return new Audi();
        }else
            return null;
    }
}

public class Main {
    public static void main(String[] args) {
        Factory carFac=new Factory();
        Car Audi = carFac.CreateCar("Audi");
        Car BMW = carFac.CreateCar("BMW");
    }
}
/*
这是一辆奥迪
这是一辆宝马
*/

4. 工厂方法模式

4.1. “开放-封闭”原则

对扩展开放，对修改关闭。简单来说添加新功能时，可以加代码，但是不能改以前的代码。简单工厂模式在工厂实现类内部固定了生产类型，因此不符合开闭原则。

场景2：今天我和厂长说我需要一辆奔驰，厂长说没有这个，我说一定要有，厂长说那只能把厂拆了重新加一个奔驰生产线。
显然，这样很不好。为了解决这种问题，于是就有了工厂方法模式。

4.2. 工厂方法模式

场景3：厂长把生产线都分开了，每个分厂一个生产线，按同一个模式装修。这样当有新的需求的时候，不需要动原来的厂，只要按照同一个模式再开一个新分厂就好了。

/**
 * 工厂接口
 * Created by wjj on 2021/1/4
 */
public interface Factory {
    public Car create();
}

/**
 * 奥迪生产厂
 * Created by wjj on 2021/1/4
 */
public class AudiFactory implements Factory{
    public AudiFactory() {
        System.out.println("这是奥迪车厂");
    }

    @Override
    public Car create() {
        return new Audi();
    }
}

/**
 * 奔驰厂
 * Created by wjj on 2021/1/4
 */
public class BenzFactory implements Factory{
    public BenzFactory() {
        System.out.println("这是奔驰车厂");
    }

    @Override
    public Car create() {
        return new Benz();
    }
}

/**
 * 宝马生产厂
 * Created by wjj on 2021/1/4
 */
public class BMWFactory implements Factory{
    public BMWFactory() {
        System.out.println("这是宝马车厂");
    }

    @Override
    public Car create() {
        return new BMW();
    }
}

public class Main {
    public static void main(String[] args) {
        Factory carFac1=new BenzFactory();
        Car Benz = carFac1.create();
        Factory carFac2=new AudiFactory();
        Car Audi = carFac2.create();
        Factory carFac3=new BMWFactory();
        Car BMW = carFac3.create();
    }
}
/*
这是奔驰车厂
这是一辆奔驰
这是奥迪车厂
这是一辆奥迪
这是宝马车厂
这是一辆宝马
*/

5. 抽象工厂模式

前面的工厂模式的特点在于都只有一个产品，那么如果一个厂要生产多个产品怎么处理？

场景4:今天我不光买了车，我还要自己买一个配套的备胎，厂长说我的厂没有备胎。那怎么办？和上面一样，我的工厂装修里都多一个生产备胎的生产线不就好了

/**
 * 备胎轮子接口
 * Created by wjj on 2021/1/4
 */
public interface Wheel {
}

public class AudiWheel implements Wheel{
    public AudiWheel() {
        System.out.println("这是奥迪轮子");
    }
}

public class BenzWheel implements Wheel {
    public BenzWheel() {
        System.out.println("这是奔驰轮子");
    }
}

public class BMWWheel implements Wheel{
    public BMWWheel() {
        System.out.println("这是奔驰轮子");
    }
}

public interface Factory {
    public Car createCar();
    public Wheel createWheel();
}

public class AudiFactory implements Factory {
    public AudiFactory() {
        System.out.println("这是奥迪车厂");
    }
    
    @Override
    public Car createCar() {
        return new Audi();
    }

    @Override
    public Wheel createWheel() {
        return new AudiWheel();
    }
}

public class BenzFactory implements Factory {
    public BenzFactory() {
        System.out.println("这是奔驰车厂");
    }

    @Override
    public Car createCar() {
        return new Benz();
    }

    @Override
    public Wheel createWheel() {
        return new BenzWheel();
    }
}

public class BMWFactory implements Factory {
    public BMWFactory() {
        System.out.println("这是宝马车厂");
    }

    @Override
    public Car createCar() {
        return new BMW();
    }

    @Override
    public Wheel createWheel() {
        return new BMWWheel();
    }
}