Java设计模式（学习笔记）--简单工厂（Simple Factory）模式

   在设计模式中,Factory Method也是比较简单的一个,但应用非常广泛,EJB,RMI,COM,CORBA,Swing中都可以看到此模式的影子,它是最重要的模式之一.在很多地方我们都会看到xxxFactory这样命名的类,那么,什么是Factory Method,为什么要用这个模式,如何用Java语言来实现该模式,这就是本文想要带给大家的内容.

工厂模式的几种形态

工厂模式专门负责将大量有共同接口的类实例化。工厂模式可以动态的决定将哪一个类实例化，工厂模式有以下几种形态：
 简单工厂（Simple Factory）模式：又称静态工厂方法（Static Factory Methord）模式。
 工厂方法（Factory Method）模式：又称多态性工厂（Polymorphic Factory）模式或虚拟构造子（Virtual Constructor）模式。
 抽象工厂（Abstract Factory）模式：又称工具箱（Kit或Toolkit）模式。

简单工厂（Simple Factory）:

简单工厂模式，或称静态工厂方法模式，是不同工厂方法模式的一个特殊实现。在Java语言中，通常的工厂方法模式不能通过设计功能的退化给出静态工厂方法模式。

简单工厂模式的引进（一般模式）
比如有一个农场，生产各种水果，有苹果（Apple）、草莓（Strawberry）、葡萄（Grape）；农场的园丁（FruitGardener）要根据客户的需求，提供相应的水果。下面看看是如何用简单工厂模式实现这个过程的，如下图：

 
此模式的实现源码如下：

 

产品接口－水果接口：Fruit.java
package com.lavasoft.patterns.simplefactory.ybgc;

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

 

产品－平果类：Apple.java
package com.lavasoft.patterns.simplefactory.ybgc;

public class Apple implements Fruit {
    private int treeAge;

    public void plant() {
        System.out.println("Apple has been planted.");
    }

    public void grow() {
        System.out.println("Apple is growing...");
    }

    public void harvest() {
        System.out.println("Apple has been harvested.");
    }

    public int getTreeAge() {
        return treeAge;
    }

    public void setTreeAge(int treeAge) {
        this.treeAge = treeAge;
    }

}

产品－草莓类：Strawberry.java
package com.lavasoft.patterns.simplefactory.ybgc;

public class Strawberry implements Fruit {

    public void grow() {
        System.out.println("Strawberry is growing...");
    }

    public void harvest() {
        System.out.println("Strawberry has been harvested.");
    }

    public void plant() {
        System.out.println("Strawberry has been planted.");
    }

    public static void log(String msg) {
        System.out.println(msg);
    }
}

 

产品－葡萄类：Grape.java

package com.lavasoft.patterns.simplefactory.ybgc;

 

public class Grape implements Fruit {
    private boolean seedless;   //是否有籽

    /**
     * 种植
     */
    public void plant() {
        System.out.println("Grape has been planted.");
    }

    /**
     * 生长
     */
    public void grow() {
        System.out.println("Grape is growing...");
    }

    /**
     * 收获
     */
    public void harvest() {
        System.out.println("Grape has been harvested.");
    }

    /**
     * @return 是否有籽
     */
    public boolean getSeedless() {
        return seedless;
    }

    /**
     * 有无籽的赋值方法
     */
    public void setSeedless(boolean seedless) {
        this.seedless = seedless;
    }

    /**
     * 辅助方法
     */
    public static void log(String msg) {
        System.out.println(msg);
    }
}

工厂－园丁类：FruitGardener.java
package com.lavasoft.patterns.simplefactory.ybgc;

public class FruitGardener {
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");
        }
    }
}

 

工厂异常定义类：BadFruitException.java

package com.lavasoft.patterns.simplefactory.ybgc;

public class BadFruitException extends Exception {
    public BadFruitException(String msg) {
        super(msg);     //调用父类的构造方法
    }
}

 

一般工厂模式的测试类
package com.lavasoft.patterns.simplefactory.ybgc;
public class TestApp {
    /**
     * 测试方法
     */
    private void test(String fruitName) {
        try {
            Fruit f = FruitGardener.factory(fruitName);
            System.out.println("恭喜!生产了一个水果对象:" + fruitName);
        } catch (BadFruitException e) {
            System.out.println("对不起!工厂目前不能生产你所要的产品:" + fruitName);
            System.out.println(e.getMessage());     //输出异常信息
            e.printStackTrace();                    //输出异常堆栈信息
        }
    }

    /**
     * 应用入口方法
     */
    public static void main(String args[]) {
        TestApp t = new TestApp();
        t.test("apple");
        t.test("grape");
        t.test("strawberry");

        t.test("car");  //此处会抛异常,水果工厂能生产car(轿车)吗!哈哈哈哈...
    }
}

 

测试运行结果
恭喜!生产了一个水果对象:apple
恭喜!生产了一个水果对象:grape
恭喜!生产了一个水果对象:strawberry
对不起!工厂目前不能生产你所要的产品:car
Bad fruit request
com.lavasoft.patterns.simplefactory.ybgc.BadFruitException: Bad fruit request
 at com.lavasoft.patterns.simplefactory.ybgc.FruitGardener.factory(FruitGardener.java:28)
 at com.lavasoft.patterns.simplefactory.ybgc.TestApp.test(TestApp.java:19)
 at com.lavasoft.patterns.simplefactory.ybgc.TestApp.main(TestApp.java:37)
 at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
 at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)
 at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)
 at java.lang.reflect.Method.invoke(Method.java:585)
 at com.intellij.rt.execution.application.AppMain.main(AppMain.java:90)

Process finished with exit code 0

从结果看来，有异常，是因为输入了工厂不能生产的类型car（小汽车）

 

简单工厂模式的一般性结构

  总结一下，从上面的简单工厂模式的实现可以看到，简单工厂模式需要实现
 工厂角色：园丁
 抽象产品：水果接口
 具体产品：苹果、葡萄、草莓
另外还一般还需要实现
 工厂异常类
 客户类
简单工厂模式的一般性结构图如下：

简单工厂模式优点：

含有必要的判断逻辑，决定什么时候创建哪一个产品的实例，而客户端可以免除直接创建产品对象的责任，而仅仅消费产品，可以对实现责任的分割。

简单工厂模式缺点：

对于消费角色来说，只需向工厂申请产品对象即可，但对于工厂角色来说，每增加一种产品都需要修改工厂角色的实现代码。  

转载：http://lavasoft.blog.51cto.com/62575/11345