工厂模式

 *******************************

 ************author：lenkou***

 ********************************

  *********************************

一、工厂模式分为三类：

1>简单工厂模式(simple factory)

 

  

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

/**
 * Created by IntelliJ IDEA.
 * FileName:Fruit.java
 * User:    LavaSoft
 * Date:    2006-12-1
 * Time:    0:26:51
 * 《Java与模式》（--阎宏博士著）读书笔记
 * 工厂模式模式--简单工厂模式--一般模式
 * ReadMe:  抽象产品角色:工厂的水果产品接口--水果
 */
public interface Fruit {
    /**
     * 种植
     */
    void plant();

    /**
     * 生长
     */
    void grow();

    /**
     * 收获
     */
    void harvest();
}

 

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

/**
 * Created by IntelliJ IDEA.
 * FileName:Apple.java
 * User:    LavaSoft
 * Date:    2006-12-1
 * Time:    0:47:25
 * 《Java与模式》（--阎宏博士著）读书笔记
 * 工厂模式模式--简单工厂模式--一般模式
 * ReadMe:  水果工厂的产品:苹果
 */
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.");
    }

    /**
     * @return 返回树龄
     */
    public int getTreeAge() {
        return treeAge;
    }

    /**
     * 设置树龄
     */
    public void setTreeAge(int treeAge) {
        this.treeAge = treeAge;
    }

}

 

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

/**
 * Created by IntelliJ IDEA.
 * FileName:Strawberry.java
 * User:    LavaSoft
 * Date:    2006-12-1
 * Time:    0:45:09
 * 《Java与模式》（--阎宏博士著）读书笔记
 * 工厂模式模式--简单工厂模式--一般模式
 * ReadMe:  水果工厂的产品:草莓
 */
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;

/**
 * Created by IntelliJ IDEA.
 * FileName:Grape.java
 * User:    LavaSoft
 * Date:    2006-12-1
 * Time:    0:36:56
 * 《Java与模式》（--阎宏博士著）读书笔记
 * 工厂模式模式--简单工厂模式--一般模式
 * ReadMe:  水果工厂的产品:葡萄
 */
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;

/**
 * Created by IntelliJ IDEA.
 * FileName:FruitGardener.java
 * User:    LavaSoft
 * Date:    2006-12-1
 * Time:    1:03:27
 * 《Java与模式》（--阎宏博士著）读书笔记
 * 工厂模式模式--简单工厂模式--一般模式
 * ReadMe:  工厂类角色: 水果园丁,生产水果产品
 */
public class FruitGardener {
    /**
     * 静态工厂方法
     * @param which :具体的产品名称
     * @return 一个水果对象
     * @throws BadFruitException
     */
    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;

/**
 * Created by IntelliJ IDEA.
 * FileName:BadFruitException.java
 * User:    LavaSoft
 * Date:    2006-12-1
 * Time:    1:04:56
 * 《Java与模式》（--阎宏博士著）读书笔记
 * 工厂模式模式--简单工厂模式--一般模式
 * ReadMe:  工厂的异常处理类
 */
public class BadFruitException extends Exception {
    public BadFruitException(String msg) {
        super(msg);     //调用父类的构造方法
    }
}

 

 一般工厂模式的测试类
package com.lavasoft.patterns.simplefactory.ybgc;

/**
 * Created by IntelliJ IDEA.
 * FileName:TestApp.java
 * User:    LavaSoft
 * Date:    2006-12-1
 * Time:    1:12:08
 * 《Java与模式》（--阎宏博士著）读书笔记
 * 工厂模式模式--简单工厂模式--一般模式
 * ReadMe:  一般工厂模式的测试类
 */
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(轿车)吗!哈哈哈哈...
    }
}

2>工厂方法模式(factory method)

  

  

水果产品接口Fruit.java
package com.lavasoft.patterns.factorymethod.ybms;

/**
 * Created by IntelliJ IDEA.
 * FileName:Fruit.java
 * User:    LavaSoft
 * Date:    2006-12-3
 * Time:    17:25:48
 * 《Java与模式》（--阎宏博士著）读书笔记
 * 工厂模式--工厂方法模式--一般性模式（农场应用）
 * ReadMe:  水果接口
 */
public interface Fruit {
    /**
     * 种植
     */
    void plant();

    /**
     * 生长
     */
    void grow();

    /**
     * 收获
     */
    void harvest();
}

 

具体产品苹果Apple.java
package com.lavasoft.patterns.factorymethod.ybms;

/**
 * Created by IntelliJ IDEA.
 * FileName:Apple.java
 * User:    LavaSoft
 * Date:    2006-12-1
 * Time:    0:47:25
 * 《Java与模式》（--阎宏博士著）读书笔记
 * 工厂模式--工厂方法模式--一般性模式（农场应用）
 * ReadMe:  水果工厂的产品:苹果
 */
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.");
    }

    /**
     * @return 返回树龄
     */
    public int getTreeAge() {
        return treeAge;
    }

    /**
     * 设置树龄
     */
    public void setTreeAge(int treeAge) {
        this.treeAge = treeAge;
    }

}

具体产品葡萄：Grape.java
package com.lavasoft.patterns.factorymethod.ybms;

/**
 * Created by IntelliJ IDEA.
 * FileName:Grape.java
 * User:    LavaSoft
 * Date:    2006-12-1
 * Time:    0:36:56
 * 《Java与模式》（--阎宏博士著）读书笔记
 * 工厂模式--工厂方法模式--一般性模式（农场应用）
 * ReadMe:  水果工厂的产品:葡萄
 */
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);
    }
}

具体产品草莓：Strawberry.java
package com.lavasoft.patterns.factorymethod.ybms;

/**
 * Created by IntelliJ IDEA.
 * FileName:Strawberry.java
 * User:    LavaSoft
 * Date:    2006-12-1
 * Time:    0:45:09
 * 《Java与模式》（--阎宏博士著）读书笔记
 * 工厂模式--工厂方法模式--一般性模式（农场应用）
 * ReadMe:  水果工厂的产品:草莓
 */
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);
    }
}

 

水果工厂接口：FruitGardener.java
package com.lavasoft.patterns.factorymethod.ybms;

/**
 * Created by IntelliJ IDEA.
 * FileName:FruitGardener.java
 * User:    LavaSoft
 * Date:    2006-12-3
 * Time:    17:22:52
 * 《Java与模式》（--阎宏博士著）读书笔记
 * 工厂模式--工厂方法模式--一般性模式（农场应用）
 * ReadMe:  水果工厂接口
 */
public interface FruitGardener {
    /**
     * 工厂方法
     *
     * @return 水果
     */
    public Fruit factory();
}

 

苹果工厂：AppleGardener.java
package com.lavasoft.patterns.factorymethod.ybms;

/**
 * Created by IntelliJ IDEA.
 * FileName:AppleGardener.java
 * User:    LavaSoft
 * Date:    2006-12-3
 * Time:    17:45:29
 * 《Java与模式》（--阎宏博士著）读书笔记
 * 工厂模式--工厂方法模式--一般性模式（农场应用）
 * ReadMe:  苹果工厂方法
 */
public class AppleGardener implements FruitGardener {
    /**
     * 工厂方法
     *
     * @return 苹果
     */
    public Fruit factory() {
        Fruit f = new Apple();
        System.out.println("水果工厂（AppletGardener）成功创建一个水果：苹果！");
        return f;
    }
}

 

葡萄工厂：GrapeGardener.java
package com.lavasoft.patterns.factorymethod.ybms;

/**
 * Created by IntelliJ IDEA.
 * FileName:GrapeGardener.java
 * User:    LavaSoft
 * Date:    2006-12-3
 * Time:    17:51:41
 * 《Java与模式》（--阎宏博士著）读书笔记
 * 工厂模式--工厂方法模式--一般性模式（农场应用）
 * ReadMe:  添加说明
 */
public class GrapeGardener implements FruitGardener {
    /**
     * 工厂方法
     *
     * @return 葡萄
     */
    public Fruit factory() {
        Fruit f = new Grape();
        System.out.println("水果工厂（GrapeGardener）成功创建一个水果：葡萄！");
        return f;
    }
}

 

草莓工厂：StrawberryGardener.java
package com.lavasoft.patterns.factorymethod.ybms;

/**
 * Created by IntelliJ IDEA.
 * FileName:StrawberryGardener.java
 * User:    LavaSoft
 * Date:    2006-12-3
 * Time:    17:53:30
 * 《Java与模式》（--阎宏博士著）读书笔记
 * 工厂模式--工厂方法模式--一般性模式（农场应用）
 * ReadMe:  添加说明
 */
public class StrawberryGardener implements FruitGardener {
    /**
     * 工厂方法
     *
     * @return 草莓
     */
    public Fruit factory() {
        Fruit f = new Strawberry();
        System.out.println("水果工厂（StrawberryGardener）成功创建一个水果：草莓！");
        return f;
    }
}

 

测试类（客户端）：TestApp.java
package com.lavasoft.patterns.factorymethod.ybms;

/**
 * Created by IntelliJ IDEA.
 * FileName:TestApp.java
 * User:    LavaSoft
 * Date:    2006-12-3
 * Time:    17:54:48
 * 《Java与模式》（--阎宏博士著）读书笔记
 * 工厂模式--工厂方法模式--一般性模式（农场应用）
 * ReadMe:  测试类（客户端）
 */
public class TestApp {
    private FruitGardener f1, f2, f3;
    private Fruit p1, p2, p3;

    private void test() {
        //实力化水果工厂
        f1 = new AppleGardener();
        f2 = new GrapeGardener();
        f3 = new StrawberryGardener();
        //从水果工厂生产水果
        p1 = f1.factory();
        p2 = f2.factory();
        p3 = f3.factory();
    }

    public static void main(String args[]) {
        TestApp test = new TestApp();
        test.test();
    }
}

3>抽象工厂模式(abstract factory)

  

 抽象工厂：Gardener.java

package com.lavasoft.patterns.abstractfactory.ybms;

/**
 * Created by IntelliJ IDEA.
 * FileName:Gardener.java
 * User:    LavaSoft
 * Date:    2006-12-5
 * Time:    22:55:23
 * 《Java与模式》（--阎宏博士著）读书笔记
 * 工厂模式--抽象工厂模式--一般性模式（农场应用）
 * ReadMe:  抽象工厂角色：工厂接口
 */
public interface Gardener {

    public Fruit createFruit(String name);

    public Veggie createVeggie(String name);
}

 

抽象水果产品：Fruit.java

package com.lavasoft.patterns.abstractfactory.ybms;

/**
 * Created by IntelliJ IDEA.
 * FileName:Fruit.java
 * User:    LavaSoft
 * Date:    2006-12-5
 * Time:    22:54:15
 * 《Java与模式》（--阎宏博士著）读书笔记
 * 工厂模式--抽象工厂模式--一般性模式（农场应用）
 * ReadMe:  抽象产品角色：水果接口
 */
public interface Fruit {
}

 

1.3.1.抽象蔬菜产品：Veggie.java
package com.lavasoft.patterns.abstractfactory.ybms;

/**
 * Created by IntelliJ IDEA.
 * FileName:Veggie.java
 * User:    LavaSoft
 * Date:    2006-12-5
 * Time:    22:56:22
 * 《Java与模式》（--阎宏博士著）读书笔记
 * 工厂模式--抽象工厂模式--一般性模式（农场应用）
 * ReadMe:  抽象产品角色：蔬菜接口
 */
public interface Veggie {
}

 

热带水果：TropicalFruit.java
package com.lavasoft.patterns.abstractfactory.ybms;

/**
 * Created by IntelliJ IDEA.
 * FileName:TropicalFruit.java
 * User:    LavaSoft
 * Date:    2006-12-5
 * Time:    22:57:08
 * 《Java与模式》（--阎宏博士著）读书笔记
 * 工厂模式--抽象工厂模式--一般性模式（农场应用）
 * ReadMe:  具体产品角色：热带水果
 */
public class TropicalFruit implements Fruit {
    private String name;

    public TropicalFruit(String name) {
        System.out.println("热带工厂为您创建了：热带水果－"+name);
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

}

 

热带蔬菜：TropicalVeggie.java
package com.lavasoft.patterns.abstractfactory.ybms;

/**
 * Created by IntelliJ IDEA.
 * FileName:TropicalVeggie.java
 * User:    LavaSoft
 * Date:    2006-12-5
 * Time:    22:58:03
 * 《Java与模式》（--阎宏博士著）读书笔记
 * 工厂模式--抽象工厂模式--一般性模式（农场应用）
 * ReadMe:  具体产品角色：热带蔬菜
 */
public class TropicalVeggie implements Veggie {
    private String name;

    public TropicalVeggie(String name) {
        System.out.println("热带工厂为您创建了：热带水果－"+name);
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

}

 

亚热带水果：NorthernFruit.java
package com.lavasoft.patterns.abstractfactory.ybms;

/**
 * Created by IntelliJ IDEA.
 * FileName:NorthernFruit.java
 * User:    LavaSoft
 * Date:    2006-12-5
 * Time:    22:58:55
 * 《Java与模式》（--阎宏博士著）读书笔记
 * 工厂模式--抽象工厂模式--一般性模式（农场应用）
 * ReadMe:  具体产品角色：亚热带水果
 */
public class NorthernFruit implements Fruit {
    private String name;

    public NorthernFruit(String name) {
        System.out.println("亚热带工厂为您创建了：亚热带水果－"+name);
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

}

亚热带蔬菜：NorthernVeggie.java
package com.lavasoft.patterns.abstractfactory.ybms;

/**
 * Created by IntelliJ IDEA.
 * FileName:NorthernVeggie.java
 * User:    LavaSoft
 * Date:    2006-12-5
 * Time:    22:59:36
 * 《Java与模式》（--阎宏博士著）读书笔记
 * 工厂模式--抽象工厂模式--一般性模式（农场应用）
 * ReadMe:  具体产品角色：亚热带蔬菜
 */
public class NorthernVeggie implements Veggie {
    private String name;

    public NorthernVeggie(String name) {
        System.out.println("亚热带工厂为您创建了：亚热带蔬菜－"+name);
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

}

 

热带工厂：TropicalGardener.java
/**
 * Created by IntelliJ IDEA.
 * FileName:TropicalGardener.java
 * User:    LavaSoft
 * Date:    2006-12-5
 * Time:    23:01:49
 * 《Java与模式》（--阎宏博士著）读书笔记
 * 工厂模式--抽象工厂模式--一般性模式（农场应用）
 * ReadMe:  具体工厂角色：热带工厂
 */
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
package com.lavasoft.patterns.abstractfactory.ybms;

/**
 * Created by IntelliJ IDEA.
 * FileName:NorthernGardener.java
 * User:    LavaSoft
 * Date:    2006-12-5
 * Time:    23:00:31
 * 《Java与模式》（--阎宏博士著）读书笔记
 * 工厂模式--抽象工厂模式--一般性模式（农场应用）
 * ReadMe:  具体工厂角色：亚热带工厂
 */
public class NorthernGardener implements Gardener {
    public Fruit createFruit(String name) {
        return new NorthernFruit(name);
    }

    public Veggie createVeggie(String name) {
        return new NorthernVeggie(name);
    }
}

 

测试类（客户端）：TestApp.java
package com.lavasoft.patterns.abstractfactory.ybms;

/**
 * Created by IntelliJ IDEA.
 * FileName:TestApp.java
 * User:    LavaSoft
 * Date:    2006-12-5
 * Time:    23:03:22
 * 《Java与模式》（--阎宏博士著）读书笔记
 * 工厂模式--抽象工厂模式--一般性模式（农场应用）
 * ReadMe:  测试类（客户端）
 */
public class TestApp {
    private void test(){
        Veggie tv,nv;
        Fruit tf,nf;
        TropicalGardener tg=new TropicalGardener();
        NorthernGardener ng=new NorthernGardener();

        tv=tg.createVeggie("热带菜叶");
        nv=ng.createVeggie("东北甜菜");
        tf=tg.createFruit("海南椰子");
        nf=ng.createFruit("雪梨");
    }
    public static void main(String args[]){
        TestApp test=new TestApp();
        test.test();
    }
}

 二、简单工厂模式、工厂方法模式、抽象工厂模式的区别

       简单工厂模式：对具体对象的抽象

      工厂方法模式：不仅对具体对象的抽象，而且对具体工厂的抽象

      抽象工厂模式：对工厂的抽象的分类抽象

      

  转贴来自：http://lavasoft.blog.51cto.com/62575/11674