【Java设计模式02】——工厂模式

转载：http://blog.csdn.net/xu__cg/article/details/52909769

工厂模式：主要是为创建对象提供接口，将创建对象的过程隔离起来，实现了创建者与调用者的分离，提高了程序的灵活性。 

核心本质：

• 实例化对象，用工厂方法代替new操作。
• 将选择实现类、创建对象统一管理和控制，从而将调用者跟我们实现类解耦。

工厂模式分类：

• 简单工厂模式（Simple Factory）
• 工厂方法模式(Factory Method)
• 抽象工厂模式(Abstract Factory)

一、简单工厂模式

组成结构：（1）抽象产品接口、（2）具体产品类、 （3）简单工厂类

//抽象产品接口:Car
interface Car {
	void run();
}

//具体产品类:Audi、Byd
class Audi implements Car {
	@Override
	public void run() {
		System.out.println("奥迪车!");
	}
}

class Byd implements Car {
	@Override
	public void run() {
		System.out.println("比亚迪车!");
	}
}

//简单工厂类:SimpleFactory
class SimpleFactory {
	
	//按类型制造车
	public Car createCar(String type) {
		if("Audi".equals(type)) {
			return new Audi();
		}else if("Byd".equals(type)) {
			return new Byd();
		}else {
			return null;
		}
	}
}


public class SimpleFactoryTest {
	public static void main(String[] args) {
		
		//创建简单工厂对象
		SimpleFactory factory = new SimpleFactory();
		Car audiCar = factory.createCar("Audi");
		Car bydCar = factory.createCar("Byd");
		audiCar.run();
		bydCar.run();
	}
}

缺点：每增加一种新型车，都要在工厂类中增加相应的创建业务逻辑（createCar(String type)方法需要新增case），这显然是违背开闭原则的 。

二、工厂方法模式

工厂方法模式：是简单工厂模式的进一步抽象化和推广，工厂方法模式里不再只由一个工厂类决定哪一个产品类应当被实例化，这个决定被交给抽象工厂的子类去做。

组成结构：（1）抽象产品接口、（2）具体产品类、 （3）抽象工厂接口、 （4）具体工厂类

//抽象产品类:Car
interface Car {
	void run();
}

//具体产品类:Audi、Byd
class Audi implements Car {
	@Override
	public void run() {
		System.out.println("奥迪车!");
	}
}

class Byd implements Car {
	@Override
	public void run() {
		System.out.println("比亚迪车!");
	}
}


//抽象工厂类:CarFactory
interface CarFactory {
	Car createCar();
}


//具体工厂类:AudiFactory、BydFactory
class AudiFactory implements CarFactory {
	@Override
	public Car createCar() {
		return new Audi();
	}
}

class BydFactory implements CarFactory {
	@Override
	public Car createCar() {
		return new Byd();
	}
}


public class FactoryMethodTest {
	public static void main(String[] args) {
		
		//创建各自的工厂
		CarFactory audiFactory = new AudiFactory();
		CarFactory bydFactory = new BydFactory();
		
		//生产各自的产品
		Car audi = audiFactory.createCar();
		Car byd = bydFactory.createCar();
		
		audi.run();
		byd.run();
	}
}

三、抽象工厂模式

        在抽象工厂模式中，抽象产品 (AbstractProduct) 可能是一个或多个，从而构成一个或多个产品族(Product Family)。如构成一辆车需要有发动机，座椅，轮胎等配件，而每个配件又有多种（如发动机有A，B不同型号），那么该抽象产品构成一个产品族。 
        当每个抽象产品都有多于一个的具体子类的时候（发动机有型号A和B两种，座椅也有型号A和B两种），工厂角色怎么知道实例化哪一个子类呢？比如每个抽象产品角色都有两个具体产品（产品轮胎有两个具体产品轮胎A和轮胎B）。抽象工厂模式提供两个具体工厂角色（A型汽车系列工厂和B型系列工厂），分别对应于这两个具体产品角色，每一个具体工厂角色只负责某一个产品角色的实例化。每一个具体工厂类只负责创建抽象产品的某一个具体子类的实例。

组成结构：（1）各类产品的抽象类、（2）各类产品的子类、（3）工厂抽象类、（4）各种工厂子类

//发动机接口及其子类A、B
interface Engine {
	void run();
}

class EngineA implements Engine {
	
	@Override
	public void run() {
		System.out.println("A类Engine, 转的快!");
	}
}

class EngineB implements Engine {
	
	@Override
	public void run() {
		System.out.println("B类Engine, 转的慢!");
	}
}


//座椅接口及其子类A、B
interface Seat {
	void message();
}

class SeatA implements Seat {
	
	@Override
	public void message() {
		System.out.println("A类Seat, 可以自动按摩!");
	}
}

class SeatB implements Seat {
	
	@Override
	public void message() {
		System.out.println("B类Seat, 可以调整高低!");
	}
}


//汽车工厂接口
interface CarFactory {
	
	//可以生产所有的产品
	Engine 	createEngine();
	Seat 	createSeat();
}

//A类汽车工厂, 能够生产EngineA和SeatA
class CarFactoryA implements CarFactory {
	@Override
	public Engine createEngine() {
		return new EngineA();
	}
	
	@Override
	public Seat createSeat() {
		return new SeatA();
	}
}

//B类汽车工厂, 能够生产EngineB和SeatB
class CarFactoryB implements CarFactory {
	@Override
	public Engine createEngine() {
		return new EngineB();
	}
	
	@Override
	public Seat createSeat() {
		return new SeatB();
	}
}


public class AbstractFactory {
	public static void main(String[] args) {
		
		CarFactory factoryA = new CarFactoryA();
		Engine eA = factoryA.createEngine();
		Seat sA = factoryA.createSeat();
		eA.run();
		sA.message();
		
		CarFactory factoryB = new CarFactoryB();
		Engine eB = factoryB.createEngine();
		Seat sB = factoryB.createSeat();
		eB.run();
		sB.message();
	}
}

抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口，而无须指定他们具体的类。它针对的是有多个产品的等级结构。