设计模式-工厂模式（Factory Pattern）

package simple;
/**
 * 简单工厂模式：生产多种型号宝马产品
 * 补充：开闭原则——>对扩展的开放，对修改的关闭
 * 缺点：每增加一种新型车,工厂类中需要增加相应的case，违背开闭原则（对扩展的开发，对修改的关闭）
 * 弥补：提出工厂方法模式，定义如下
 * 工厂类定义成了接口,而每新增的车种类型,就增加该车种类型对应工厂类的实现,
 * 这样工厂的设计就可以扩展了,而不必去修改原来的代码。
 */
//产品类
interface BMW{
	
}
class BMW320 implements BMW{
	public BMW320() {
		System.out.println("制造 BMW320");
	}
}
class BMW523 implements BMW{
	public BMW523() {
		 System.out.println("制造 BMW523");
	}
}
//工厂类
class Factory{
	public BMW createBMW(int type) { //根据参数不同，返回不同的产品（对象）
		switch (type) {
		case 320:
			return new BMW320();
		case 523:
			return new BMW523();
		default:
			break;
		}
		return null;
	}
}
//顾客类
public class Customer {
	public static void main(String[] args) {
		Factory factory = new Factory();
		factory.createBMW(320);
		factory.createBMW(523);
	}
}

package method;
/**
 * 工厂方法模式：生产多种型号宝马产品
 * 缺点：如果要生产多个产品，此将不再适用
 * 弥补：提出抽象工厂模式，特点如下
 * 抽象工厂模式有多个抽象产品类，具体工厂类可以创建多个具体产品类的实例
 */
//产品类
interface BMW{
	
}
class BMW320 implements BMW{
	public BMW320() {
		System.out.println("生产BMW320");
	}
}
class BMW523 implements BMW{
	public BMW523() {
		System.out.println("生产BMW523");
	}
}
//工厂类
interface FactoryBMW{
	public BMW createBWM();
}
class FactoryBMW320 implements FactoryBMW{
	@Override
	public BMW createBWM() { //父类作为方法返回值实现多态
		// TODO Auto-generated method stub
		return new BMW320(); //返回该工厂生产的产品
	}	
}
class FactoryBMW523 implements FactoryBMW{
	@Override
	public BMW createBWM() {
		// TODO Auto-generated method stub
		return new BMW523();
	}
}
//客户类
public class Customer {
	public static void main(String[] args) {
		//创建320型号宝马的工厂
		FactoryBMW320 factoryBMW320 = new FactoryBMW320();
		factoryBMW320.createBWM();
		//创建523型号宝马的工厂
		FactoryBMW523 factoryBMW523 = new FactoryBMW523();
		factoryBMW523.createBWM();
	}
}

package ecjtu.mjh.abstr;
/**
 * 抽象工厂模式:生产汽车的多种配件的多种型号产品
 * 两个重要概念：
 * 产品等级结构：产品的继承结构。
 * 产品族：在抽象工厂模式中，产品族（Dough、Sauce）是指由同一个工厂生产的，
 * 位于不同产品等级结构中的一组产品。
 */
//产品类
//产品1：引擎
interface Engine{
	
}
class EngineA implements Engine{
	public EngineA() {
		System.out.println("生产引擎A");
	}
}
class EngineB implements Engine{
	public EngineB() {
		System.out.println("生产引擎B");
	}
}
//产品2：轮胎
interface Tyre{
	
}
class TyreA implements Tyre{
	public TyreA() {
		System.out.println("生产轮胎A");
	}
}
class TyreB implements Tyre{
	public TyreB() {
		System.out.println("生产轮胎B");
	}
}
//工厂类
//抽象工厂接口
interface AbstractFactory{
	public Engine createEngine();
	public Tyre createTyre();
}
class FactoryBMW320 implements AbstractFactory{ 
    //生产宝马320系列配件的工厂：需要引擎A和轮胎A
	@Override
	public Engine createEngine() {
		// TODO Auto-generated method stub
		return new EngineA();
	}

	@Override
	public Tyre createTyre() {
		// TODO Auto-generated method stub
		return new TyreA();
	}
	
}
class FactoryBMW523 implements AbstractFactory{ 
    //生产宝马523系列配件的工厂：需要引擎B和轮胎B
	@Override
	public Engine createEngine() {
		// TODO Auto-generated method stub
		return new EngineB();
	}

	@Override
	public Tyre createTyre() {
		// TODO Auto-generated method stub
		return new TyreB();
	}
	
}
public class Customer {
	public static void main(String[] args) {
		//要生产宝马320的配件的工厂
		FactoryBMW320 f320 = new FactoryBMW320();
		f320.createEngine();
		f320.createTyre();
		
		//要生产宝马523的配件的工厂
		FactoryBMW523 f523 = new FactoryBMW523();
		f523.createEngine();
		f523.createTyre();
	}
}