Java 可复用的面向对象的设计模式之 工厂模式Factory详解 :简单工厂模式 工厂方法模式 抽象工厂模式

A:

设计模式之Factory(简单工厂模式、工厂方法和抽象工厂)

了解反射：

Class.forName().newInstance();

1.简单工厂方法

角色：

具体工厂

抽象产品

具体产品

比喻：

一个产业结构单一，只专门一个产品领域的小工厂，如软件。

2工厂方法

角色：

抽象工厂：不做具体的工作，完成生产产品所必须的工作，如：申明产权

具体工厂

抽象产品

具体产品

比喻：

   公司在发展，开始生产不同领域的产品，如软件和硬件。

3抽象工厂方法

角色：

产品族：不同领域产品的组合，譬如：计算机产品

抽象工厂

具体工厂

抽象产品

具体产品

比喻：

企业壮大，开始融合自己的产品，如经济性计算机、商业性计算机等等，其中每个具体工厂只生产自己产品族的产品。

下面是详细讲解和小例子：

注意理解上面的比喻，更有利于理解工厂模式（Factory）

1.Simple Factory

适用情况：

一般情况下，简单工厂使用于类的分类不太明显，类关系单一，种类不多，而且不经常更新的情况，当然，我也是初学者，不能考虑到方方面面，在前进中寻找吧！

  优点：

方便创建多种对象，不易混淆，逻辑清晰。

缺点：

工厂类的工作会随着类种类的增加而加重。

例子代码（注：代码是没有实际意义的，没有运行的必要，可能存在语法错误）：

小企业：生产电脑硬件CPU，如CPUa,CPUb,CPUc分别代表三个种类的CPU

public abstract class CPU{

}

public class CPUa extends CPU{

public void getInfo() {

System.out.println("CPUa");

}

} 

public class CPUb extends CPU{

public void getInfo() {

System.out.println("CPUb");

}

} 

public class CPUc extends CPU{

public void getInfo() {

System.out.println("CPUc");

}

} 

具体的工厂类：

Public class CPUFactory {

Public static CPU produceCPU(Type t){   //一般只用于返回新对象，所以一般方法为static，便于使用，提高效率

If(t==a)

Return new CPUa();

If(t==b)

Return new CUPb();

If(t==c)

Rerurn new CPUc();

}

}

客户端使用情况：

Publci class Client {

Public static void main(Stirng args[]) {

CPUFarctioy.produce(a).getInfo();

}

2.抽象工厂模式

适用情况：

一般类的分类明显，继承关系清晰，类的种类繁多，将其归类后使用此模式。

优点：

减少了工厂类的负担，责任更清晰，每个具体工厂产出一类对象，方便扩展，便于增加新的类分支。

例子程序：

中型企业：

生产CPU和操作系统OS,例如：OSa.OSb,OSc代表不同种类。

public abstract class CPU{

}

public class CPUa extends CPU{

public void getInfo() {

System.out.println("CPUa");

}

} 

public class CPUb extends CPU{

public void getInfo() {

System.out.println("CPUb");

}

} 

public class CPUc extends CPU{

public void getInfo() {

System.out.println("CPUc");

}

} 

public abstract class OS{

}

public class OSa extends OS{

public void getInfo() {

System.out.println("OSa");

}

} 

public class OSb extends OS{

public void getInfo() {

System.out.println("OSb");

}

} 

public class OSc extends OS{

public void getInfo() {

System.out.println("OSc");

}

} 

抽象工厂：

Public interface MFactory {

Public Product produce()

{

Sys.out.pirntln("Made by MFactoty!"):

}

}

Public class MFactoryCPU {

Public CPU produce(Type t)

{

If(t==a)

Return new CPUa();

If(t==b)

Return new CUPb();

If(t==c)

Rerurn new CPUc();

}

}

Public class MFFactoryOS　｛

Public OS produce(Type t)

{

If(t==a)

Return new  OSa();

If(t==b)

Return new  OSb();

If(t==c)

Rerurn new OSc();

}

｝

客户端：

Publci class Client {

Public static void main(Stirng args[]) {

NewMFactoryCPU().produce(a).getINfo();

newMFactoyrOS().produce(b).getInfo();

}

3.抽象工厂

适用情况：

类种类繁多，而且各个种类之间的类有不同的交互协作。

例子代码：

大企业，生产电脑COMP，种类分别为COMPa,COMPb,COMPc

CPU和OS的代码同上

抽象工厂：
public interface Factory{

ProduceCPU(Type);

ProduceOS(Type);

};

Public class Factorya{

//用于生成COMPa所需的a类配件OS和CPU

ProduceCPU(){

Reuturn new CPUa();

}

ProduceOS(){

Return new OSa);

}

}

Public class Factoryb{

//用于生成COMPa所需的b类配件OS和CPU

ProduceCPU(){

Reuturn new CPUb();

}

ProduceOS(){

Return new OSb();

}

}

Public class Factoryc{

//用于生成COMPa所需的a类配件OS和CPU

ProduceCPU(){

Reuturn new CPUc();

}

ProduceOS(){

Return new OSc();

}

}

应用端：

Publci class COMPFactory {

produceCOMP(Factory f) {

Return f.produceCPU()+f.produceOS();

}          //一定要注意参数是Factory

}

Publci class Client {

Public static void main(Stirng args[]) {

COMP computer = COMPFactory.produceCOMP(new Factorya);

}

就写到这里了，渴望大家的意见和批评！