Java常见设计模式之工厂模式

阳光穿透心脏的1/2处 2021-12-01 21:06 276阅读 0赞

工厂模式在我们日常的应用中应当算是比较广泛的一种设计模式了。今天让我们一起来学习一下，工厂的设计模式。

工厂模式在《Java与模式》中分为三类：  
     1）简单工厂模式（Simple Factory）：不利于产生系列产品；  
     2）工厂方法模式（Factory Method）：又称为多形性工厂；  
     3）抽象工厂模式（Abstract Factory）：又称为工具箱，产生产品族，但不利于产生新的产品；  
        这三种模式从上到下逐步抽象，并且更具一般性。  
        GOF在《设计模式》一书中将工厂模式分为两类：工厂方法模式（Factory Method）与抽象工厂模式（Abstract Factory）。将简单工厂模式（Simple Factory）看为工厂方法模式的一种特例，两者归为一类。

**      1、简单工厂模式**       
     简单工厂模式又称为静态工厂，在简单工厂模式中,一个工厂类处于对产品类实例化调用的中心位置上,它决定那一个产品类应当被实例化, 如同一个交通警察站在来往的车辆流中,决定放行那一个方向的车辆向那一个方向流动一样。

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

使用Java代码实现相关内容:

有一个农场公司，专门向市场销售各类水果。有如下水果：  
     ● 葡萄（grape）  
     ● 草莓（strawberry）  
     ● 苹果（apple）

package com.yonyou.factory;
    
    /**
     * 水果通用接口函数
     * @author 小浩
     * @创建日期 2015-4-6
     */
    public interface Fruit
    {
    /**
    * 水果与其它植物相比有一些专门的属性，以便与农场的
    * 其它植物区分开。这里的水果假设它必须具备的方法：
    * 生长grow()、收获harvest()、种植plant()
    */
    void grow();
    void harvest();
    void plant();
    }

package com.yonyou.factory;
    
    /**
     * 苹果的实现类
     * @author 小浩
     * @创建日期 2015-4-6
     */
    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; }
    }

package com.yonyou.factory;
    /**
     * 草莓的实体类
     * @author 小浩
     * @创建日期 2015-4-6
     */
    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; }
    
    }

package com.yonyou.factory;
    
    /**
     * 下面是Grape类的函数Grape.java:
     * @author 小浩
     * @创建日期 2015-4-6
     */
    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; }
    
    }

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

package com.yonyou.factory;
    
    /**
     * 园丁工厂类
     * @author 小浩
     * @创建日期 2015-4-6
     */
    public class FruitGardener
    {
    /**
    * 通过下面的表态工厂方法，可以根据客户的需要，创建出不同的水果对象
    * 如果提供的参数是“apple”则通过“return new Apple()”创建出苹果实例
    * 如果是提供的参数是“grape”则创建葡萄实例，这正是简单工厂方法之精髓
    */
    public static Fruit factory(String which)
    {
    if (which.equalsIgnoreCase("apple")) { 
    	return new Apple();
    	}
    else if(which.equalsIgnoreCase("strawberry")){
    	return new Strawberry(); 
    	}
    else if(which.equalsIgnoreCase("grape")){
    	return new Grape(); 
    	}
    else
    return null;
     }
    }

**2、工厂方法模式**

** **    工厂方法模式是简单工厂模式的进一步抽象化和推广，工厂方法模式里不再只由一个工厂类决定那一个产品类应当被实例化,这个决定被交给抽象工厂的子类去做。  
　　来看下它的组成：  
      1)抽象工厂角色： 这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现。  
      2)具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。  
      3)抽象产品角色：它是具体产品继承的父类或者是实现的接口。在java中一般有抽象类或者接口来实现。  
      4)具体产品角色：具体工厂角色所创建的对象就是此角色的实例。在java中由具体的类来实现。  
      工厂方法模式使用继承自抽象工厂角色的多个子类来代替简单工厂模式中的“上帝类”。正如上面所说，这样便分担了对象承受的压力；而且这样使得结构变得灵活 起来——当有新的产品（即暴发户的汽车）产生时，只要按照抽象产品角色、抽象工厂角色提供的合同来生成，那么就可以被客户使用，而不必去修改任何已有的代 码。可以看出工厂角色的结构也是符合开闭原则的！

Java代码实现工厂方法的设计模式

由于水果接口以及grape类、strawberry类、apple类的代码都和上面的一样的。下面主要讲解不一样的部分。

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

package com.yonyou.factory;
    
    /**
     * 园丁工厂通用接口
     * @author 小浩
     * @创建日期 2015-4-6
     */
    public interface FruitGardener
    {
       Fruit factory();
    }

package com.yonyou.factory;
    
    /**
     * 生产苹果的专用工厂
     * @author 小浩
     * @创建日期 2015-4-6
     */
    public class AppleGardener implements FruitGardener{
    
    	@Override
    	public Fruit factory() {
            return new Apple();		
    	}
    }

package com.yonyou.factory;
    
    /**
     * 生产草莓的专用工厂
     * @author 小浩
     * @创建日期 2015-4-6
     */
    public class StrawberryGardener implements FruitGardener{
    
    	@Override
    	public Fruit factory() {
    		return new Strawberry();
    	}
    
    }

package com.yonyou.factory;
    
    /**
     * 生产葡萄的专用工厂
     * @author 小浩
     * @创建日期 2015-4-6
     */
    public class GrapeGardener implements FruitGardener{
    
    	@Override
    	public Fruit factory() {
    		return new Grape();
    	}
    
    }

由以上源码可以看出，使用工厂方法模式保持了简单工厂模式的优点，克服了其缺点。当在系统中引入新产品时，既不必修改客户端，又不必修改具体工厂角色。可以较好的对系统进行扩展。但是当产品种类非常多时，会出现大量的与之对应的工厂对象，这不是我们所希望的。这样我们就引入的抽象工厂的概念了。

工厂方法模式和简单工厂模式在定义上的不同是很明显的。工厂方法模式的核心是一个抽象工厂类,而不像简单工厂模式, 把核心放在一个实类上。工厂方法模式可以允许很多实的工厂类从抽象工厂类继承下来, 从而可以在实际上成为多个简单工厂模式的综合,从而推广了简单工厂模式。  
反过来讲,简单工厂模式是由工厂方法模式退化而来。设想如果我们非常确定一个系统只需要一个实的工厂类, 那么就不妨把抽象工厂类合并到实的工厂类中去。而这样一来,我们就退化到简单工厂模式了。  
  
      **3.抽象工厂模式**

抽象工厂：意的意图在于创建一系列互相关联或互相依赖的对象。<<Java设计模式>>

我自己觉得抽象工厂是在工厂方法的基础上引进了分类管理的概念....工厂方法用来创建一个产品，它没有分类的概念，而抽象工厂则用于创建一系列相关的或者相互依赖的产品，所以产品分类成了抽象工厂的重点。抽象工厂只是创建一系列相互依赖或关联地产品的借口，是针对类的设计模式。工厂方法是定一个一个接口，让子类去实例化，是针对对象的设计模式。

现在经营范围近一步扩大，不仅生产水果了，而且开始种植蔬菜了。现在工厂再次大发展，要引进塑料大棚技术，在大棚里种植热带（Tropical）和亚热带的水果和蔬菜（Veggie）。其中水果分为TropicalFruit和NorthernFruit，蔬菜分为TropicalVeggie和NorthernVeggie。园丁包括TropicalGardener和NorthernGardener。也就是说，TropicalGardener专门管理TropicalFruit和TropicalGardener，NorthernGardener专门管理NorthernFruit和NorthernVeggie。 这时候如果使用工厂方法的设计模式的话，我们需要为蔬菜和水果在分别写一个单独的工厂，但由于水果和蔬菜的关系比较紧密，属于相关类型。这时我们可以使用抽象工厂的设计模式，将生产蔬菜和水果的接口放到一起。也可以这样理解，由于蔬菜可水果有很多相似的地方，我们就没必要安排两个园丁来管理它们了。由于亚热带和热带植物的差别较大，那样我们就使用两个不同的园丁来分别管理热带和亚热带的水果和蔬菜。

抽象工厂模式在这个例子中的源码如下所示：

package com.yonyou.factory;
    
    /**
     * 创建蔬菜接口
     * @author 小浩
     * @创建日期 2015-4-6
     */
    public interface Vegetables {
    	/**
    	* 蔬菜与其它植物相比有一些专门的属性，以便与农场的
    	* 其它植物区分开。这里的蔬菜假设它必须具备的方法：
    	* 生长grow()、收获harvest()、种植plant()
    	*/
    	void grow();
    	void harvest();
    	void plant();
    }

package com.yonyou.factory;
    
    /**
     * 园丁工厂通用接口
     * @author 小浩
     * @创建日期 2015-4-6
     */
    public interface Gardener
    {
    	//创建生产水果的工厂
       Fruit factoryFruit();
        //创建生产蔬菜的工厂
       Vegetables factoryVegetables();
    
    }

//亚热带园丁

package com.yonyou.factory;
    
    /**
     * 生产亚热带水果和蔬菜的园丁
     * @author 小浩
     * @创建日期 2015-4-6
     */
    public class NorthernGardener implements Gardener{
    
    	@Override
    	public Fruit factoryFruit() {
    		//亚热带的草莓
    		return new Strawberry();
    	}
    
    	@Override
    	public Vegetables factoryVegetables(){
    		//亚热带的西红柿
    		return new Tomato();
    	}
    
    }

//热带园丁

package com.yonyou.factory;
    
    /**
     * 创建热带的园丁，只负责生产热带水果和蔬菜
     * @author 小浩
     * @创建日期 2015-4-6
     */
    public class TropicalGardener implements Gardener{
    
    	@Override
    	public Fruit factoryFruit() {
    		//返回热带苹果
    		return new Apple();
    	}
    
    	@Override
    	public Vegetables factoryVegetables() {
    		//返回亚热带蔬菜西红柿
    		return new Tomato();
    	}
    	
    }

比如现在要增加南方水果（SouthFruit）和南方蔬菜（SouthVeggie）。那么只要增加如下代码即可很容易的扩展：

package com.yonyou.factory;
    
    /**
     * 创建南方的园丁，只负责生产热带水果和蔬菜
     * @author 小浩
     * @创建日期 2015-4-6
     */
    public class SouthGardener implements Gardener{
    
    	@Override
    	public Fruit factoryFruit() {
    		//返回南方葡萄
    		return new Grape();
    	}
    
    	@Override
    	public Vegetables factoryVegetables() {
    		//返回南方蔬菜西红柿
    		return new Tomato();
    	}
    	
    }

**     四.总结**  
  
（1）简单工厂模式是由一个具体的类去创建其他类的实例，父类是相同的，父类是具体的。  
（2）工厂方法模式是有一个抽象的父类定义公共接口，子类负责生成具体的对象，这样做的目的是将类的实例化操作延迟到子类中完成。  
（3）抽象工厂模式提供一个创建一系列**相关或相互依赖（需要注意的地方）**象的接口，而无须指定他们具体的类。它针对的是有多个产品的等级结构。而工厂方法模式针对的是一个产品的等级结构。

=======下面是我参考的一个博客的原始内容，感兴趣的话亦可以看看===========================

工厂模式细分有三种，分别为：简单工厂模式、工厂方法模式、抽象工厂模  
式。现单个的讲，最后再讲这三个的区别。  
这篇文章主要通过一个农场的实例来讲解，这也是《java与模式》书中的例  
子，只不过我对一些部分进行了简化，一些部分进行了扩充，以帮助理解。例  
子如下：  
有一个农场公司，专门向市场销售各类水果。有如下水果：  
● 葡萄（grape）  
● 草莓（strawberry）  
● 苹果（apple）  
  
**简单工厂模式：**  
  
这个比较简单，写一下源代码。源代码中给出了必须的注释。代码比书上的要  
简单一些，排版也好看一些，只是为了让新手更好的理解。  
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"); \}  
\}  
\}  
  
简单工厂方法的优点是当在系统中引入新产品时不必修改客户端，但需要个修改工厂  
类，将必要的逻辑加入到工厂类中。工厂方法模式就克服了以上缺点，下面谈谈工厂  
方法模式。  
  
**工厂方法模式:**  
由于水果接口以及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(); \}  
\}  
  
由以上源码可以看出，使用工厂方法模式保持了简单工厂模式的优点，克服了其缺点。  
当在系统中引入新产品时，既不必修改客户端，又不必修改具体工厂角色。可以较好  
的对系统进行扩展。  
  
**抽象工厂模式：**  
现在工厂再次大发展，要引进塑料大棚技术，在大棚里种植热带（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://www.cnblogs.com/xiohao/p/4395413.html