设计模式——抽象工厂模式

抽象工厂模式是所有形态的工厂模式中最为抽象和最具一般性的。抽象工厂模式可以向客户端提供一个接口，使得客户端在不必指定产品的具体类型的情况下，能够创建多个产品族的产品对象。

（1）创建一个Fruit接口

package com.meritit;

public interface Fruit {

	/*
	 * 采集
	 */
	public void get();
}

（2）创建一个Apple抽象类

package com.meritit;

public abstract class Apple implements Fruit{
	/*
	 * 采集
	 */
	public abstract void get();
}

（3）创建一个Banana抽象类

package com.meritit;

public abstract class Banana implements Fruit{
	/*
	 * 采集
	 */
	public abstract void get();
}

（4）实现抽象的Apple，分为南方和北方两个产品族

package com.meritit;

public class SouthApple extends Apple{

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

}

package com.meritit;

public class NorthApple extends Apple{

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

}

同样Banana也分为南方和北方

package com.meritit;

public class SouthBanana extends Banana{

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

}

package com.meritit;

public class NorthBanana extends Banana{

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

（5）创建一个抽象的工厂方法（该工厂方法分为两个产品族）

package com.meritit;

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

（6）实现南方族工厂方法和北方族工厂方法

package com.meritit;


public class SouthFruitFactory implements FruitFactory {

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

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

package com.meritit;

public class NorthFruitFactory implements FruitFactory{

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

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


}

（7）可以根据族而实例化不同族不同产品对象

package com.meritit;

public class MainClass {
	
	public static void main(String[] args) throws Exception {
		FruitFactory northFactory = new NorthFruitFactory();
		Fruit apple1 = northFactory.getApple();
		apple1.get();
		Fruit banana1 = northFactory.getBanana();
		banana1.get();
		
		FruitFactory southFactory = new SouthFruitFactory();
		Fruit apple2 = southFactory.getApple();
		apple2.get();
		Fruit banana2 = southFactory.getBanana();
		banana2.get();
	}	
}

上面的关系如图

下面我们来看一下这种设计模式的好处，假如我们要添加一个温室族的产品。

（1）添加WenshiApple和WenshiBanana

package com.meritit;

public class WenshiApple extends Apple{

	@Override
	public void get() {
		System.out.println("采集温室苹果");
	}

}

package com.meritit;

public class WenshiBanana extends Banana{

	@Override
	public void get() {
		System.out.println("采集温室香蕉");
	}

}

(2)添加族工厂WenshiFruitFactory

package com.meritit;

public class WenshiFruitFactory implements FruitFactory{

	@Override
	public Fruit getApple() {
		return new WenshiApple();
	}

	@Override
	public Fruit getBanana() {
		return new WenshiBanana();
	}

}

现在的结构如图：

这样非常符合开放封闭原则，外部是开放的外部是封闭的。

但是这种方法也有缺点，当需要增加一个新的水果的时候，要对 每个族工厂进行代码的修改。

抽象工厂模式的角色：

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

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

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

（4）具体产品角色：抽象模式所创建的具体实例。