上期回顾：公司在扩大的同时，招的员工不再是只有程序员了。需要招销售员，这样就给原有的结构有了较大的冲击。以前的那个模式已经不再适用，接下来我们将使用抽象工厂模式来解决这个问题。

实现：我们将进一步抽象。不管是程序员还是销售员，都是员工，对于公司招人来说，员工已经可以达到最高抽象级别了

员工接口

public interface Employee {
	void work();
}

程序员接口

public interface Programmer extends Employee {
}

java程序员

public class JavaProgrammer implements Programmer{
	public void work() {
		System.out.println("I am develop java softeware");
	}
}

csharp程序员

public class CsharpProgrammer implements Programmer {
	public void work() {
		System.out.println("I am develop csharp softeware");
	}
}

php程序员

public class PhpProgrammer implements Programmer {

	public void work() {
		System.out.println("I am develop php softeware");
	}

}

ruby程序员

public class RubyProgrammer implements Programmer {

	public void work() {
		System.out.println("I am develop ruby softeware");
	}

}

销售员接口

public interface Seller extends Employee {
}

java销售员

public class JavaSeller implements Seller {

	public void work() {
		System.out.println("I am selling java software");
	}

}

csharp销售员

public class CsharpSeller implements Seller {

	public void work() {
		System.out.println("I am selling csharp software");
	}

}

公司职能

public interface AbstractFactory {
	Employee getEmployee();
}

java开发部门

public class JavaFactory implements AbstractFactory {

	public Employee getEmployee() {
		return new JavaProgrammer();
	}

}

csharp开发部门

public class CsharpFactory implements AbstractFactory {

	public Employee getEmployee() {
		return new CsharpProgrammer();
	}

}

php开发部门

public class PhpFactory implements AbstractFactory {

	public Employee getEmployee() {
		return new PhpProgrammer();
	}

}

Ruby开发部门

public class RubyFactory implements AbstractFactory {

	public Employee getEmployee() {
		return newRubyProgrammer();
	}

}

java销售部门

public class JavaSellerFactory implements AbstractFactory {

	public Employee getEmployee() {
		return new JavaSeller();
	}

}

csharp销售部门

public class CsharpSellerFactory implements AbstractFactory {

	public Employee getEmployee() {
		return new CsharpSeller();
	}

}

创建好了，现在我需要一个java销售人员

public static void main(String[] args) {
		System.out.println("I want a java seller");
		AbstractFactory factory=new JavaSellerFactory();
		Employee seller=factory.getEmployee();
		seller.work();
	}

完美的工作着……

接下来我需要找一个清洁工

public class Cleaner implements Employee {

	public void work() {
		System.out.println("I am cleaning......");
	}

}

创建清洁部门

public class CleanFactory implements AbstractFactory {

	public Employee getEmployee() {
		return new Cleaner();
	}

}

清洁工开始工作

public static void main(String[] args) {
		System.out.println("I want a cleaner");
		AbstractFactory factory=new CleanFactory();
		Employee seller=factory.getEmployee();
		seller.work();
	}

原来的代码不需要任何的变动，只需要增加相应的员工和部门就好了。

总结：工厂模式分为三种：简单工厂、工厂方法和抽象工厂。在使用时首先要确定工厂生产的类别是否唯一，如果是可以考虑前两种，如果不是需要使用第三种。工厂方法比简单工厂更开放，更符合OO的开闭原则，但具体使用时，如果生产的对象可以确定，那么可以考虑使用简单工厂。

（*文中的例子只是为了说明问题，如有不恰当之处还望见谅）