GOF23-工厂模式

工厂模式

工厂模式、简单工厂模式、抽象工厂模式

一、简单工厂模式

举个例子：一家工厂生产销售两种品牌的车，Mazda和BWM，工厂根据实际传入的参数获取对应的车辆。

1、先定义一个接口

public interface Car{
	void print();
}

2、定义两个实现类

public class Mazda implement Car{
	@Override
	public void print(){
		System.out.println("this is Mazda");
	}
}

public class BWM implement Car{
	@Override
	public void print(){
		System.out.println("this is BWM");
	}
}

3、定义一个简单工厂

public class CarFactroy{
	public static Car buyCar(String type){
		if(type.equls("Mazda")){
			Car car = new Mazda();
			car.print();
			return car;
		}else if(type.equls("BWM")){
			Car car = new Mazda();
			car.print();
			return car;
		}else {
			return null;
		}
	}
}

简单工厂模式：职责单一，当前汽车工厂只负责生产汽车，根据传入的参数不同而返回不同的实现了car接口的子类实例。

二、工厂模式

工厂模式其实是对简单工厂模式的提升，如果业务需要多个工厂的话则可引入工厂模式。
举个例子：Mazda 生产Mazda 3 和 Mazda 6，BWM 生产 BWM 325li 和525li。
这样我们就需要两个工厂，一个是Mazda工厂，一个是BWM工厂。

1、定义两个接口

public interface CarFactory(){
    Car gerCar(String type);
}

public interface Car{
	void print();
}

2、定义四种车和两个工厂

public class MazdaFactory implement CarFactory{
	@Override
	public Car getCar(String type){
		if(type.equls("Mazda 3")){
			Car car = new Mazda3();
			car.print();
			return car;
		}else if(type.equls("Mazda 6")){
			Car car = new Mazda6();
			car.print();
			return car;
		}else {
			return null;
		}
	}
}


public class BWMFactory implement CarFactory{
	@Override
	public Car getCar(String type){
		if(type.equls("BWM 325li")){
			Car car = new BWM325li();
			car.print();
			return car;
		}else if(type.equls("BWM 525li")){
			Car car = new BWM525li();
			car.print();
			return car;
		}else {
			return null;
		}
	}
}

public class Mazda3 implement Car{
	@Override
	public void print(){
		System.out.println("this is Mazda3 ");
	}
}

public class Mazda6 implement Car{
	@Override
	public void print(){
		System.out.println("this is Mazda6 ");
	}
}

public class BWM325li implement Car{
	@Override
	public void print(){
		System.out.println("this is BWM325li ");
	}
}

public class BWM525li implement Car{
	@Override
	public void print(){
		System.out.println("this is BWM525li ");
	}
}

4、调用测试

public class demo{
	public static void mian(String[] args) {
       CarFactory factory = new MazdaFactory();
       Car car = factory.getCar("Mazda 3")
	}
}

简单工厂模式核心在于选取合适的工厂。

三、抽象模式

当遇到涉及到一组产品时或者说是产品组时就需要用到抽象模式。
举个例子，车子是由发动机、变速箱、底盘悬挂组成的。
这里用伪代码表达一下：

EngineFactory ef = new MazdaEngineFactory();
Engine engine = ef.getEngine();

TransmissionBoxFactory tf = new BWMTransmissionBoxFactory();
TransmissionBox tb = tf.getTrasmissionBox();

ChassisFactory cf = new HongQiChassisFactory();
Chassis chassis = cf.getChassis();

Car car = new Car(engine,tb,chassis)

我们不难看出，如果单独从零件的角度来看工厂，如果我们需要加入轮胎的零件比较容易扩展，只需要加一个新的工厂，而且不需要改原有的工厂。但是这种方式会出现车辆的零件可以随意搭配，但实际上某些车的零件是不匹配的。所以引出了抽象工厂，这里实现是不在已零件为单位建立工厂，而是直接定义车辆工厂。

1、定义车辆抽象工厂

public abstarct class CarFactory{
	Engine  getEngine();
	TransmissionBox  getTrasmissionBox();
	Chassis getChassis();
}

2、定义工厂类

public class MazdaFactory extend CarFactory{
	public Engine getEngine(){
		return new MazdaEngine();
	}
	public TransmissionBox  getTrasmissionBox(){
		return new MazdaTransmissionBox();
	}
	public Chassis getChassis(){
		return new MazdaChassis();
	}
}

public class BWMFactory extend CarFactory{
	public Engine getEngine(){
		return new BWMEngine();
	}
	public TransmissionBox  getTrasmissionBox(){
		return new BWMTransmissionBox();
	}
	public Chassis getChassis(){
		return new BWMChassis();
	}
}

public class HongQiFactory extend CarFactory{
	public Engine getEngine(){
		return new HongQiEngine();
	}
	public TransmissionBox  getTrasmissionBox(){
		return new HongQiTransmissionBox();
	}
	public Chassis getChassis(){
		return new HongQiChassis();
	}
}

这样一来可以根据品牌的工厂来获取产品组。但是抽象工厂模式也有其缺点，如果我们需要加轮胎，那就要改原有的代码，这个点违反了对修改关闭，对扩展
开发的原则。所以当我们在使用工厂模式设计的时候要有所考虑。