android设计模式之抽象工厂模式

定义

抽象工厂模式定义为为创建一组相关或者相互依赖的对象提供一个接口，而且无需指定他们的具体类。它是工厂方法模式的升级版本。在有多个业务品种，业务分类时，通过抽象工厂模式产生需要的对象是一种非常好的解决方式。

模式中包含的角色及其职责

1.抽象工厂（Creator）角色
抽象工厂模式的核心，包含对多个产品结构的声明，任何工厂类都必须实现这个接口。

2.具体工厂（Concrete  Creator）角色
具体工厂类是抽象工厂的一个实现，负责实例化某个产品族中的产品对象。

3.抽象（Product）角色
抽象模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口。

4.具体产品（ConcreteProduct）角色
抽象模式所创建的具体实例对象

总结：抽象工厂中方法对应产品结构，具体工厂对应产品族。

//抽象产品类
public abstract class AbstractProductA {
	// 每个产品共有的方法
	public void shareMethod() {

	}

	// 每个产品相同的方法,不同的实现
	public abstract void doSomething();
}

//抽象产品类
public abstract class AbstractProductB {
	// 每个产品共有的方法
	public void shareMethod() {

	}

	// 每个产品相同的方法,不同的实现
	public abstract void doSomething();
}


//产品A1的实现类
public class ProductA1 extends AbstractProductA {

	@Override
	public void doSomething() {
		System.out.println("产品A1的实现方法");
	}

}

//产品A2的实现类
public class ProductA2 extends AbstractProductA {

	@Override
	public void doSomething() {
		System.out.println("产品A2的实现方法");
	}

}

//产品B1的实现类
public class ProductB1 extends AbstractProductB{

	@Override
	public void doSomething() {
		System.out.println("产品B1的实现方法");
	}

}

//产品B2的实现类
public class ProductB2 extends AbstractProductB {

	@Override
	public void doSomething() {
		System.out.println("产品B2的实现方法");
	}

}

//抽象工厂
public abstract class AbstractCreator {
	// 创建A产品族
	public abstract AbstractProductA createProductA();

	// 创建B产品族
	public abstract AbstractProductB createProductB();
}


//产品等级1的实现类
public class Creator1 extends AbstractCreator {

	// 只产生产品等级为1的A产品
	public AbstractProductA createProductA() {
		return new ProductA1();
	}

	// 只产生产品等级为1的B产品
	public AbstractProductB createProductB() {
		return new ProductB1();
	}

}


//产品等级2的实现类
public class Creator2 extends AbstractCreator {

	// 只产生产品等级为2的A产品
	public AbstractProductA createProductA() {
		return new ProductA2();
	}

	// 只产生产品等级为2的B产品
	public AbstractProductB createProductB() {
		return new ProductB2();
	}

}


//场景类
public class Client {

	public static void main(String[] args) {
		// 定义出两个工厂
		AbstractCreator creator1 = new Creator1();
		AbstractCreator creator2 = new Creator2();

		// 产生A1对象
		AbstractProductA a1 = creator1.createProductA();
		// 产生2对象
		AbstractProductA a2 = creator2.createProductA();

		// 产生B1对象
		AbstractProductB b1 = creator1.createProductB();
		// 产生B2对象
		AbstractProductB b2 = creator2.createProductB();

		/**
		 * 然后在这里就可以为所欲为了..
		 * */
	}

}

另一个具体例子

public interface FruitFactory {
	//实例化Apple
	public Fruit getApple();
	//实例化Banana
	public Fruit getBanana();
}

public class NorthFruitFactory implements FruitFactory {

	public Fruit getApple() {
		return new NorthApple();
	}

	public Fruit getBanana() {
		return new NorthBanana();
	}

}

public class SouthFruitFactory implements FruitFactory {

	public Fruit getApple() {
		return new SouthApple();
	}

	public Fruit getBanana() {
		return new SouthBanana();
	}

}

public interface Fruit {
	/*
	 * 采集
	 */
	public void get();
}

public class NorthApple extends Apple {

	public void get() {
		System.out.println("采集北方苹果");
	}

}

public class NorthBanana extends Banana {

	public void get() {
		System.out.println("采集北方香蕉");
	}

}

public class SouthApple extends Apple {

	public void get() {
		System.out.println("采集南方苹果");
	}

}

public class SouthBanana extends Banana {

	public void get() {
		System.out.println("采集南方香蕉");
	}

}


public class MainClass {
	public static void main(String[] args) {
		FruitFactory ff = new NorthFruitFactory();
		Fruit apple = ff.getApple();
		apple.get();
		
		Fruit banana = ff.getBanana();
		banana.get();
		
		FruitFactory ff2= new SouthFruitFactory();
		Fruit apple2 = ff2.getApple();
		apple2.get();
		
		Fruit banana2 = ff2.getBanana();
		banana2.get();
	}
}

问题

增加新的产品族时，只需要向系统中加入新的具体工厂类就可以了，没有必要修改已有的工厂角色或者产品角色。因此，在系统中的产品族增加时，抽象工厂模式是支持“开一闭”原则的。

增加新的产品等级结构时，需要修改所有的工厂角色，给每一个工厂类都增加一个新的工厂方
法，而这显然是违背“开一闭”原则的。

比较

抽象工厂模式与工厂方法模式的最大区别就在于，工厂方法模式针对的是一个产品等级结构;而抽象工厂模式则需要面对多个产品等级结构。