简单工厂,工厂方法和抽象工厂模式(我也凑凑热闹)

02-12-20 richardluopeng
    

简单工厂,工厂方法和抽象工厂模式

作者:罗鹏 Email:luopeng@ec.com.cn

对于简单工厂来说,它的工厂只能是这个样子的

public class SimplyFactory {

/**

* 静态工厂方法

*/

public static Prouct factory(String which) throw NoSuchProductExcption

{

if(which.equalIgnoreCase("product1"))

{

return new Product1();

}

else if(which.equalsIgnoreCase("product2"))

{

return new Product2();

}

else if(which.equalsIgnoreCase("product3"))

{

return new Product3();

}

else throw NoSuchProductExcption("NoSuchProduct");

}

}

}

而对产品Product1,Product2,Product3,可以执行接口Product,也可以不执行接口Product(当然这样不好),这个Product接口只是用来抽象具体product用的

public interface Product

{

void productMethod1(); //这些只是

void productMethod2();

void productMethod3();

}

对工厂来说,只要有这么一种产品,一般来说就要在工厂里有它的生产的方法, 否则抛出异常,而要工厂生产的话,也必须下达生产什么产品的命令,至少要向工厂发出信号,让工厂足以区分是要生产什么产品,否则工厂是不知道生产哪一种产品,

对于简单工厂来说,就是需要在工厂中枚举所有的产品,所以说简单工厂还是非常笨的。

if(which.equalIgnoreCase("product1")) 只是用来区分生产什么产品的标记值,(也可以根据产品其它属性来判断,比如产品类型,产品大小,总之能够区分是什么产品的属性,或者是与产品属性相关的变量) 或者说标记值是A,生产A产品,或者工厂里定义不是这样的,我偏偏要生产B产品,或者再特殊一些,我偏偏要生产A产品+B产品,那么就要return new ProductA()+new ProductB()了。

这样,我们就可以看出一个问题来,如果要能够被简单工厂生产出来,就必须在简单工厂中有能够生产出的它的方法定义,当然还需要有这个具体产品类的定义,就是有class对应,这样确保在简单工厂中new 它的时候不会抛出 NoSuchProduct的Exception.

对于工厂方法来说

实质上它是让工厂实现了抽象的工厂接口,它把具体怎么生产一种东西,放在具体的工厂去实现了,所谓”延迟到子类中实现“

public interface Creator

{

public Prouct factory();

}

public SubCreator1 implent Creator

{

public Prouct factory()

{

return new ConcreteProduct1();

}

}

public SubCreator2 implent Creator

{

public Prouct factory()

{

return new ConcreteProduct2();

}

}

请注意:返回类型是Product型的!!

这样客户端调用是直接new 一个具体工厂的实例,然后命令它去生产,而对于具体工厂的父类(既工厂接口,接口完全可以改成子类继承父类来实现,只是这样不好,不符合OO的原则),它完全不知道什么产品被生产了,甚至它连那个具体工厂被实例化它都不知道

抽象工厂模式

抽象工厂模式主要是用来解决具体产品是有几类产品簇的问题

public interface Creator

{

public ProuctA factoryA();

public ProuctB factoryB();

}

public interface ProductA //ProductA 接口

{

}

public interface ProductB //ProductB 接口

{

}

public class ConCreator1 implent Creator

{

public ProuctA factoryA()

{

return new ConcreteProductA1();

}

public ProuctB factoryB()

{

return new ConcreteProductB1();

}

}

public class ConCreator2 implent Creator

{

public ProuctA factoryA()

{

return new ProductA2();

}

public ProuctB factoryB()

{

return new ProductB2();

}

}

public class ProductA1 implements ProductA

{

public ProductA1()

{

}

}

public class ProductA2 implements ProductA

{

public ProductA2()

{

}

}

public class ProductB1 implements ProductB

{

public ProductB1()

{

}

}

public class ProductB2 implements ProductB

{

public ProductB2()

{

}

}

实际上是这样的

1,两个工厂类ConCreator1,ConCreator2都实现了Creator接口

2,ProuctA1,ProductA2都实现了ProductA接口

3,ProuctB1,ProductB2都实现了ProductB接口

4,ConCreator1负责生产ProductA类型的产品(包括ProductA1,ProductB1)

5,ConCreator2负责生产ProductB类型的产品(包括ProductA2,ProductB2)

6,工厂方法也有这样的特征,也就是说Creator不知道什么被生产出来,甚至不知道ConCreator1还是ConCreator2被实例化了,因为client高兴调那一个工厂,就调那一个工厂,就是说工厂能生产什么,对客户端是可见的。甚至还有一种情况,客户端高兴起来就生产了ProductA1,我就不生产ProductA2,因为上面的例子中它们还都是松散的,没有绑定在一起

于是提出另外一个例子,也是老提起的电脑类型的例子

1,电脑生产商是接口,

2,CUP是接口,

3,硬盘是接口,

4,IBM工厂是制造IBM品牌的电脑的工厂

5,DELL工厂是制造DEll品牌的电脑的工厂

为讨论方便,就认为电脑=CUP+硬盘;

6,所以呀CUP有IBM的CPU和DELL的CPU

7,同样硬盘也是有IBM的硬盘和DELL的硬盘

8,IBM工厂生产IBM的CPU和IBM的硬盘,绝对不生产DELL的CPU,也不生产DELL的硬盘

9,同样DELL工厂也是一样

public interface 电脑生产商

{

public CPU 制造CPU();

public 硬盘 制造硬盘();

}

public interface CPU

{

}

public interface 硬盘

{

}

public class IBM的CPU implements CPU

{

public IBM的CPU();

}

public class IBM的硬盘 implements 硬盘

{

public IBM的硬盘();

}

public class DELL的CPU implements CPU

{

public DELL的CPU();

}

public class DELL的硬盘 implements 硬盘

{

public DELL的硬盘();

}

//下面是IBM工厂

public class IBM工厂

{

private CPU IBM的CPU私有变量=null;

private 硬盘 IBM的硬盘私有变量=null;

private CPU 制造IBMCPU()

{

return new IBM的CPU();

}

private 硬盘 制造IBM硬盘()

{

return new IBM的CPU();

}

public 电脑 制造IBM电脑()

{

try{

IBM的CPU私有变量=制造IBMCPU();

IBM的硬盘私有变量=制造IBM硬盘();

if(IBM的CPU私有变量!=null&&IBM的硬盘私有变量!=null)

retrun (IBM的CPU私有变量+IBM的硬盘私有变量);

//组装成IBM电脑

}

catch(Exception e)

{

System.out.println("制造IBM电脑失败!");

}

}

}

}

这样,客户端无法通过命令单生产出一个CPU来,这样抽象才真正成为一个完整产品的工厂,只要向工厂发出生产的命令,一台完整的电脑就生产出来了,而工厂怎么生产的,生产了哪些部件,外界就看不见了,外界就知道这个工厂是生产IBM电脑整机的工厂!

DELL电脑工厂一样