抽象工厂设计模式

这个设计模式又将方法工厂设计模式更为抽象了一层 

我们的方法工厂设计模式只能生产 Coder  ，这一点就是 方法工厂设计模式和抽象工厂设计模式最大的不同，其他的很类似

首先 我们需要搞清楚 两个 概念 产品簇和等级结构

比如我们不仅仅是要码农，我们还要设计师，我们需要IOS 的Coder 和Designer   和 JAVA 的Coder 和Designer   

这样就分为了两个产品簇 。一个跟JAVA相关的产品簇 ，一个跟IOS相关的产品簇。 而 设计师和码农就是两个不同的等级，不同的等级由不同的抽象产品类管理 如Coder 和 Designer

我们分别由一个具体工厂JAVAEmployeeFactory 和 IOSEmployeeFactory 来管理一个产品簇，工厂拥有生成Coder和 Designer的方法。

将工厂抽象出来，Factory 抽象工厂所具有的方法就有两个：生产Coder 和生成Designer

和工厂方法相同的是 还有由 抽象工厂 具体工厂 抽象产品 具体产品构成 不过就是在工厂上分了类，分了簇的概念。

上代码：

package abstractfactory;
/*
 * 抽象工厂  可以被继承为各类工程
 */
public interface Fatory {
	public Coder buildCoder(String level);
	public Designer buildDesigner(String levle);
}

package abstractfactory;

public class IOSEmployeeFactory implements Fatory {

	@Override
	public Coder buildCoder(String level) {
		return new IOScoder( level);
	}
	@Override
	public Designer buildDesigner(String level) {
		return new IOSDesigner( level);
	}	
}

package abstractfactory;

public class JAVAEmployeeFactory implements Fatory {

	@Override
	public Coder buildCoder(String level) {
		return new JavaCoder(level);
	}
	@Override
	public Designer buildDesigner(String level) {
		return new JavaDesigner(level);
	}	
}

package abstractfactory;

public interface Coder {
	//程序员敲代码的抽象方法
	
	public void Code();
		
}

package abstractfactory;
/**
 * IOS开发程序员
 * @author coffee
 *
 */
public class IOScoder implements Coder {
	//具体的实现方法
	String level;
	public IOScoder(String level) {
		this.level = level;
	}
	@Override
	public void Code() {
		System.out.println(level+"写代码，开发IOS项目");
	}
	
}

package abstractfactory;
/**
 * java程序员
 * @author coffee
 *
 */
public class JavaCoder implements Coder {
	String level;
	public JavaCoder(String level) {
		this.level =level;
	}
	//具体的实现方法
	@Override
	public void Code() {
		System.out.println(level+"写代码，开发Java项目");
	}
	
}

package abstractfactory;

public interface Designer {
	//设计师设计的抽象方法
	public void Design();
		
}

package abstractfactory;
/**
 * IOS开发程序员
 * @author coffee
 *
 */
public class IOSDesigner implements Designer {
	String level;
	public IOSDesigner(String level) {
		this.level =level;
	}
	@Override
	public void Design() {
		System.out.println(level+"设计IOS项目");
	}
	
}

package abstractfactory;
/**
 * java程序员
 * @author coffee
 *
 */
public class JavaDesigner implements Designer {
	String level;
	public JavaDesigner(String level) {
		this.level=level;
	}
	//具体的实现方法
	@Override
	public void Design() {
		System.out.println(level+"设计Java项目");
	}
	
}

package abstractfactory;

public class Test {
	public static void main(String[] args) {		
	Fatory fatory= new IOSEmployeeFactory();
	Coder coder = fatory.buildCoder("中级程序员");
	coder.Code();
	}
}

测试用例中发现 我们不必要关心具体的实现子类，只需要关心什么工厂。

这样的设计 可以面对多产品的需求了。 工厂抽象， 产品抽象。