设计模式——工厂模式

简单工厂

 简单工厂模式是属于创建型模式，又叫做静态工厂方法（Static Factory Method）模式，但不属于23种GOF设计模式之一。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式，可以理解为是不同工厂模式的一个特殊实现。

1、首先我们定义抽象产品类（或接口）

package Factory;
public interface Product {
	//声明类所需要继承的抽象类或接口
}

2、定义产品类A和B

package Factory;
public class ProductA implements Product{
	public ProductA(){
		System.out.println("ProductA");
	}
}
package Factory;
public class ProductB implements Product{
	public ProductB(){
		System.out.println("ProductB");
	}
}

3、定义简单工厂类

package Factory;
//简单工厂类
public class SimpleFactory {
	public Product createProduct(String str){
		Product product = null;
		switch(str){
			case "A":
				product = new ProductA();
				break;
			case "B":
				product = new ProductB();
		}
		return product;
	}
}

4、客户端代码

package Factory;
public class Main {
	public static void main(String[] args){
		//简单工厂
		SimpleFactory Sf = new SimpleFactory();
		//调用工厂方法产生对应的产品类
		Product product = Sf.createProduct("A");
	}
}

优点：简单工厂模式能够根据外界给定的信息，决定究竟应该创建哪个具体类的对象。明确区分了各自的职责和权力，有利于整个软件体系结构的优化。
缺点：很明显工厂类集中了所有实例的创建逻辑，容易违反GRASPR的高内聚的责任分配原则。

工厂

 工厂方法模式Factory Method，又称多态性工厂模式。在工厂方法模式中，核心的工厂类不再负责所有的产品的创建，而是将具体创建的工作交给子类去做。该核心类成为一个抽象工厂角色，仅负责给出具体工厂子类必须实现的接口，而不接触哪一个产品类应当被实例化这种细节。

1、定义一个抽象工厂类（或接口）

package Factory;
//工厂接口
public interface Factory {
	public Product createProduct();
}

2、实现具体的工厂子类

package Factory;
public class FactoryA implements Factory{
	public Product createProduct() {
		// TODO Auto-generated method stub
		return new ProductA();
	}
}
package Factory;
public class FactoryB implements Factory{
	public Product createProduct(){
		return new ProductB();
	}
}

3、客户端代码

package Factory;
public class Main {
	public static void main(String[] args){
		//工厂
		Factory f;
		f = new FactoryA();
		Product product = f.createProduct();
	}
}

优点：

• 子类提供挂钩。基类为工厂方法提供缺省实现，子类可以重写新的实现，也可以继承父类的实现。-- 加一层间接性，增加了灵活性
• 屏蔽产品类。产品类的实现如何变化，调用者都不需要关心，只需关心产品的接口，只要接口保持不变，系统中的上层模块就不会发生变化。
• 典型的解耦框架。高层模块只需要知道产品的抽象类，其他的实现类都不需要关心，符合迪米特法则，符合依赖倒置原则，符合里氏替换原则。
• 多态性：客户代码可以做到与特定应用无关，适用于任何实体类。

缺点：需要Creator和相应的子类作为factory method的载体，如果应用模型确实需要creator和子类存在，则很好；否则的话，需要增加一个类层次。

抽象工厂模式

 抽象工厂模式是所有形态的工厂模式中最为抽象和最具一般性的一种形态。抽象工厂模式是指当有多个抽象角色时，使用的一种工厂模式。抽象工厂模式可以向客户端提供一个接口，使客户端在不必指定产品的具体的情况下，创建多个产品族中的产品对象。根据里氏替换原则，任何接受父类型的地方，都应当能够接受子类型。因此，实际上系统所需要的，仅仅是类型与这些抽象产品角色相同的一些实例，而不是这些抽象产品的实例。换言之，也就是这些抽象产品的具体子类的实例。工厂类负责创建抽象产品的具体子类的实例。

1、存在多个产品类对象

比如在上面Product类的基础上增加Gift类

//增加Gift接口
package Factory;
public interface Gift {
	//声明产品赠品的接口，当然也可以是抽象类，同样为了简单就不声明方法了
}
//实现Gift具体类A
package Factory;
public class GiftA implements Gift{
	public GiftA(){
		System.out.println("GiftA");
	}
}
//实现Gift具体类B
package Factory;
public class GiftB implements Gift {
	public GiftB(){
		System.out.println("GiftB");
	}
}

2、实现抽象工厂接口（或方法）

package Factory;
//声明Product类工厂和Gift类工厂的工同工厂接口
public interface AbstractFactory {
	public Product createProduct();
	public Gift createGift();
}

3、实现具体的工厂类

将多个产品类组合起来

package Factory;
public class AbstractFactoryA implements AbstractFactory{
	public Product createProduct(){
		return new ProductA();
	}
	public Gift createGift() {
		return new GiftA();
	}
}
package Factory;
public class AbstractFactoryB implements AbstractFactory{
	public Product createProduct(){
		return new ProductB();
	}
	public Gift createGift() {
		return new GiftB();
	}
}

4、客户端代码

package Factory;
public class Main {
	public static void main(String[] args){
		//抽象工厂
		AbstractFactory Af;
		Af = new AbstractFactoryA();
		Gift ga = Af.createGift();
		Product product = Af.createProduct();
		
	}
}

优点

• 抽象工厂模式隔离了具体类的生产，使得客户并不需要知道什么被创建。
• 当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。
• 增加新的具体工厂和产品族很方便，无须修改已有系统，符合“开闭原则”。
  缺点：
• 增加新的产品等级结构很复杂，需要修改抽象工厂和所有的具体工厂类，对“开闭原则”的支持呈现倾斜性。