欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

java 设计模式--工厂模式

程序员文章站 2024-03-17 23:41:10
...

工厂模式在《Java与模式》中分为三类:
1)简单工厂模式(Simple Factory):不利于产生系列产品;
2)工厂方法模式(Factory Method):又称为多形性工厂;
3)抽象工厂模式(Abstract Factory):又称为工具箱,产生产品族,但不利于产生新的产品;

           这三种模式从上到下逐步抽象,并且更具一般性。
            GOF在《设计模式》一书中将工厂模式分为两类:工厂方法模式(Factory Method)与抽象工厂模式(Abstract Factory)。将简单工厂模式(Simple Factory)看为工厂方法模式的一种特例,两者归为一类。

现单个的讲,最后再讲这三个的区别
这篇文章主要通过一个农场的实例来讲解,这也是java与模式书中的例
子,只不过我对一些部分进行了简化,一些部分进行了扩充,以帮助理解例
子如下:
有一个农场公司,专门向市场销售各类水果有如下水果:
葡萄(grape)

草莓(Strawberry)
苹果(apple)

简单工厂模式:

简单工厂模式又称静态工厂方法模式。重命名上就可以看出这个模式一定很简单。它存在的目的很简单:定义一个用于创建对象的接口。
在简单工厂模式中,一个工厂类处于对产品类实例化调用的中心位置上,它决定那一个产品类应当被实例化, 如同一个交通警察站在来往的车辆流中,决定放行那一个方向的车辆向那一个方向流动一样。

     先来看看它的组成:
        1) 工厂类角色:这是本模式的核心,含有一定的商业逻辑和判断逻辑。在java中它往往由一个具体类实现。
        2) 抽象产品角色:它一般是具体产品继承的父类或者实现的接口。在java中由接口或者抽象类来实现。
        3) 具体产品角色:工厂类所创建的对象就是此角色的实例。在java中由一个具体类实现。

java 设计模式--工厂模式
这个比较简单,写一下源代码源代码中给出了必须的注释代码比书上的要
简单一些,排版也好看一些,只是为了让新手更好的理解

Fruit.java:
public interface Fruit
{
/**
* 水果与其它植物相比有一些专门的属性,以便与农场的
* 其它植物区分开这里的水果假设它必须具备的方法:
* 生长grow()收获harvest()种植plant()
*/
void grow();
void harvest();
void plant();
}

下面是Apple类的函数Apple.java:

public class Apple implements Fruit
{
/** 
* 苹果是水果类的一种,因此它必须实现水果接口的所有方法即
* grow()harvest()plant()三个函数另外,由于苹果是多年生植物,
* 所以多出一个treeAge性质,描述苹果的树龄
*/
private int treeAge;
public void grow() { //苹果的生长函数代码 }
public void harvest() { //苹果的收获函数代码 }
public void plant() { //苹果的种植函数代码 }
public int getTreeAge() { return treeAge; }
public void setTreeAge(int treeAge) { this.treeAge = treeAge; }
}

下面是Grape类的函数Grape.java:

public class Grape implements Fruit
{
/** 
* 葡萄是水果类的一种,因此它必须实现水果接口的所有方法即
* grow()harvest()plant()三个函数另外,由于葡萄分为有籽和无籽
* 两种,因此多出一个seedless性质,描述葡萄有籽还是无籽
*/
private boolean seedless;
public void grow() { //葡萄的生长函数代码 }
public void harvest() { //葡萄的收获函数代码 }
public void plant() { //葡萄的种植函数代码 }
public boolean getSeedless() { return seedless; }
public void setSeedless(boolean seedless) { this.seedless = seedless; }
}

下面是Strawberry类的函数Strawberry.java:

public class Strawberry implements Fruit
{
/** 
* 草莓是水果类的一种,因此它必须实现水果接口的所有方法即
* grow()harvest()plant()三个函数另外,这里假设草莓分为大棚草莓和一般
* 草莓(即没有棚的草莓)因此草莓比一般水果多出一个性质coteless,描述草莓
* 是大棚草莓还是没有大棚的草莓
*/
private boolean coteless;
public void grow() { //草莓的生长函数代码 }
public void harvest() { //草莓的收获函数代码 }
public void plant() { //草莓的种植函数代码 }
public boolean getCoteless() { return coteless; }
public void setCoteless(boolean coteless) { this. coteless = coteless; }
}

农场的园丁也是系统的一部分,自然要有一个合适的类来代表,我们用FruitGardener类
来表示FruitGardener类会根据客户端的要求,创建出不同的水果对象,比如苹果(apple),
葡萄(grape)或草莓(strawberry)的实例代码如下所示:
FruitGardener.java:

public class FruitGardener
{
/**
* 通过下面的表态工厂方法,可以根据客户的需要,创建出不同的水果对象
* 如果提供的参数是apple则通过return new Apple()创建出苹果实例
* 如果是提供的参数是grape则创建葡萄实例,这正是简单工厂方法之精髓
*/
public static Fruit factory(String which) throws BadFruitException
{
if (which.equalsIgnoreCase("apple")) { return new Apple(); }
else if (which.equalsIgnoreCase("strawberry")) { return new Strawberry(); }
else if (which.equalsIgnoreCase("grape")) { return new Grape(); }
else { throw new BadFruitException("Bad fruit request"); }
}
}

简单工厂方法的优点是当在系统中引入新产品时不必修改客户端,但需要个修改工厂
类,将必要的逻辑加入到工厂类中工厂方法模式就克服了以上缺点,下面谈谈工厂
方法模式

工厂方法模式:

java 设计模式--工厂模式

工厂方法模式是简单工厂模式的进一步抽象化和推广,工厂方法模式里不再只由一个工厂类决定那一个产品类应当被实例化,这个决定被交给抽象工厂的子类去做。
  来看下它的组成:

     1)抽象工厂角色: 这是工厂方法模式的核心,它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现。
      2)具体工厂角色:它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。
      3)抽象产品角色:它是具体产品继承的父类或者是实现的接口。在java中一般有抽象类或者接口来实现。
      4)具体产品角色:具体工厂角色所创建的对象就是此角色的实例。在java中由具体的类来实现。


由于水果接口以及grape类strawberry类apple类的代码都和上面的一样,所以下
面相关的源码去掉了注释
Fruit.java:

public interface Fruit
{
void grow();
void harvest();
void plant();
}

Apple.java:

public class Apple implements Fruit
{
private int treeAge;
public void grow() { //苹果的生长函数代码 }
public void harvest() { //苹果的收获函数代码 }
public void plant() { //苹果的种植函数代码 }
public int getTreeAge() { return treeAge; }
public void setTreeAge(int treeAge) { this.treeAge = treeAge; }
}

Grape.java:

public class Grape implements Fruit
{
private boolean seedless;
public void grow() { //葡萄的生长函数代码 }
public void harvest() { //葡萄的收获函数代码 }
public void plant() { //葡萄的种植函数代码 }
public boolean getSeedless() { return seedless; }
public void setSeedless(boolean seedless) { this.seedless = seedless; }
}

Strawberry.java:

public class Strawberry implements Fruit
{
private boolean coteless;
public void grow() { //草莓的生长函数代码 }
public void harvest() { //草莓的收获函数代码 }
public void plant() { //草莓的种植函数代码 }
public boolean getCoteless() { return coteless; }
public void setCoteless(boolean coteless) { this. coteless = coteless; }
}

下面的源码就是工厂方法模式的重点了,在简单工厂模式中,将这里将FruitGardener定
义为一个类,即园丁要管理园里的所有水果,如果园丁哪天病了,水果都不能管理了
在工厂方法模式中将FruitGardener定义为一个接口,而将管理水果的角色划分得更细,
比如有
葡萄园丁草莓园丁苹果园丁等等具体角色实现FruitGardener接口的工厂
方法源码如下所示:
接口FruitGardener的源码:

public interface FruitGardener
{
Fruit factory();
}

苹果园丁类AppleGardener.java的源码:

public class AppleGardener implements FruitGardener
{
public Fruit factory() { return new Apple(); }
}

葡萄园丁类GrapeGardener.java的源码:

public class GrapeGardener implements FruitGardener
{
public Fruit factory() { return new Grape(); }
}

草莓园丁类StrawberryGardener.java的源码:

public class StrawberryGardener implements FruitGardener
{
public Fruit factory() { return new Strawberry(); }
}

由以上源码可以看出,使用工厂方法模式保持了简单工厂模式的优点,克服了其缺点
当在系统中引入新产品时,既不必修改客户端,又不必修改具体工厂角色可以较好
的对系统进行扩展

抽象工厂模式:

java 设计模式--工厂模式


现在工厂再次大发展,要引进塑料大棚技术,在大棚里种植热带(Tropical)和亚热带的
水果和蔬菜(Veggie)其中水果分为TropicalFruit和NorthernFruit,蔬菜分为TropicalVeggie
和NorthernVeggie园丁包括TropicalGardener和NorthernGardener也就是说,
TropicalGardener专门管理TropicalFruit和TropicalGardener,NorthernGardener专门
管理NorthernFruit和NorthernVeggie抽象工厂模式在这个例子中的源码如下所示:
Fruit.java:

public interface Fruit { }

NorthernFruit.java:

public class NorthernFruit implements Fruit
{
private String name;
public NorthernFruit(String name) { }
public String getName() { return name; }
public void setName(String name) { this.name = name; }
}

TropicalFruit.java:

public class TropicalFruit implements Fruit
{
private String name;
public TropicalFruit(String name) { }
public String getName() { return name; }
public void setName(String name) { this.name = name; }
}

Veggie.java:

public interface Veggie { }
TropicalVeggie.java:
public class TropicalVeggie implements Veggie
{
private String name;
public TropicalVeggie(String name) { }
public String getName() { return name; }
public void setName(String name) { this.name = name; }
}

NorthernVeggie.java:

public class NorthernVeggie implements Veggie
{
private String name;
public NorthernVeggie(String name) { }
public String getName() { return name; }
public void setName(String name) { this.name = name; }
}

Gardener.java:

public interface Gardener
{
Fruit createFruit(String name);
Veggie createVeggie(String name);
}

TropicalGardener.java:

public class TropicalGardener implements Gardener
{
public Fruit createFruit(String name) { return new TropicalFruit(name); }
public Veggie createVeggie(String name) { return new TropicalVeggie(name); }
}

NorthernGardener.java:

public class NorthernGardener implements Gardener
{
public Fruit createFruit(String name) { return new NorthernFruit(name); }
public Veggie createVeggie(String name) { return new NorthernVeggie(name); }
}

为了简单起见,这里只讲一下增加新产品(族)时该系统如何扩展(关于产品族相关
知识,请看此书的相关章节,不过不懂产品族也没有关系,这里写得很简单,肯定能
看懂)比如现在要增加南方水果(SouthFruit)和南方蔬菜(SouthVeggie)那
么只要增加如下代码即可很容易的扩展:
SouthFruit.java:

public class SouthFruit implements Fruit
{
private String name;
public SouthFruit (String name) { }
public String getName() { return name; }
public void setName(String name) { this.name = name; }
}

SouthVeggie.java:

public class SouthVeggie implements Veggie
{
private String name;
public SouthVeggie (String name) { }
public String getName() { return name; }
public void setName(String name) { this.name = name; }
}

SouthGardener.java:

public class SouthGardener implements Gardener
{
public Fruit createFruit(String name) { return new SouthFruit(name); }
public Veggie createVeggie(String name) { return new SouthVeggie(name); }
}


转载于:https://my.oschina.net/u/569297/blog/291838

上一篇: C++vector容器使用

下一篇: