public Product1 getProduct1() {
return new Product1A();
}
}
//具体的工厂B，创造产品B
class FactoryB implements Factory{
public Product getProduct() {
return new ProductB();
}
//添加相应的实现
public Product1 getProduct1() {
return new Product1B();
}
}
//抽象产品
interface Product{}
//具体产品
class ProductA implements Product{}
class ProductB implements Product{}
//多了一个抽象产品1
interface Product1{}
//具体产品1
class Product1A implements Product1{}
class Product1B implements Product1{}
//原有的工厂方法模式的工厂里添加一个方法
interface Factory{
Product getProduct();
//添加另外一个产品族的创造方法
Product1 getProduct1();
}
//具体的工厂A，创造产品A
class FactoryA implements Factory{
public Product getProduct() {
return new ProductA();
}
//添加相应的实现
public Product1 getProduct1() {
return new Product1A();
}
}
//具体的工厂B，创造产品B
class FactoryB implements Factory{
public Product getProduct() {
return new ProductB();
}
//添加相应的实现
public Product1 getProduct1() {
return new Product1B();
}
} 与工厂方法对比下就发现，多了一个产品系列叫Product1，工厂接口里多了一个方法，叫getProduct1，所以抽象工厂模式就是工厂方法模式添加了抽象产品所演变而来的。
有关工厂的三个模式到这里就全部介绍完了，三者有着很大的关联和明显的关系，要想灵活运用这三种设计模式，还是要彻底理解它们所针对的问题以及三者的关系。下面罗列下这三种设计模式依次进化的原因。
1，首先从简单工厂进化到工厂方法，是因为工厂方法弥补了简单工厂对修改开放的弊端，即简单工厂违背了开闭原则。
2，从工厂方法进化到抽象工厂，是因为抽象工厂弥补了工厂方法只能创造一个系列的产品的弊端。
各位可以思考下，假设我们不使用抽象工厂模式，改用工厂方法去处理抽象工厂中多产品的问题，如何处理呢？其实很简单，就是有几个产品系列，我们就造几个工厂方法模式就可以了，只不过这样处理未免太不优雅，就像下面这样。
[java]
//抽象产品
interface Product{}
//具体产品
class ProductA implements Product{}
class ProductB implements Product{}
//工厂接口
interface Factory{
Product getProduct();
}
//具体的工厂A，创造产品A
class FactoryA implements Factory{
public Product getProduct() {
return new ProductA();
}
}
//具体的工厂B，创造产品B
class FactoryB implements Factory{
public Product getProduct() {
return new ProductB();
}
}
/* 以上是一个产品的工厂方法 */
//抽象产品1
interface Product1{}
//具体产品1
class Product1A implements Product1{}
class Product1B implements Product1{}
//工厂接口1
interface Factory1{
Product1 getProduct1();
}
//具体的工厂1A，创造产品1A
class Factory1A implements Factory1{
public Product1 getProduct1() {
return new Product1A();
}
}
//具体的工厂1B，创造产品1B
class Factory1B implements Factory1{
public Product1 getProduct1() {
return new Product1B();
}
}
//抽象产品
interface Product{}
//具体产品
class ProductA implements Product{}
class ProductB implements Product{}
//工厂接口
interface Factory{
Product getProduct();
}
//具体的工厂A，创造产品A
class FactoryA implements Factory{
public Product getProduct() {
return new ProductA();
}
}
//具体的工厂B，创造产品B
class FactoryB implements Factory{
public Product getProduct() {
return new ProductB();
}
}
/* 以上是一个产品的工厂方法 */
//抽象产品1
interface Product1{}
//具体产品1
class Product1A implements Product1{}
class Product1B implements Product1{}
//工厂接口1
interface Factory1{
Product1 getProduct1();
}
//具体的工厂1A，创造产品1A
class Factory1A implements Factory1{
public Product1 getProduct1() {
return new Product1A();
}
}
//具体的工厂1B，创造产品1B
class Factory1B implements Factory1{
public Product1 getProduct1() {
return new Product1B();
}
}
以上用两个工厂方法模式，代替了抽象工厂模式，那么可想而知，假设又多了一个