设计模式之工厂模式
为了帮助更好的理解工厂模式，我们采用汽车生产的例子
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();
}
}
