小草的天空

一、创建模式(Creational Pattern) --> 对类的实例化过程的抽象化
        分类： 
            a.类的创建模式        -->把类的创建延迟到子类，从而封装了子类的具体实现
            b.对象的创建模式    -->把对象的创建过程动态的委派给另一个对象,从而动态的决定客户端需要哪些类的实例，以及这些类是如何被创建和组合在一起的
       包含的具体模式有：
            工厂模式、单（多）例模式、建造模式、原始模型模式 等等
二、简单工厂模式（Simple Factory)  --->静态工厂方法模式(Static Factory Method Pattern)
        1.工厂模式分为3种
               a.简单工厂模式（Simple Factory）
               b.工厂方法模式（Factory Method）
               c.抽象工厂模式（Abstract Factory）
        2.Simple Factory : 就是由一个工厂对象决定创建出哪一个产品的实例
        3.UML图
            
        4.简单测试代码如下：
            

 1/** *//**
 2 * 定义一个接口 和 两个实现类
 3 */
 4public interface IFruit {
 5    /** *//**
 6     * 种植
 7     */
 8    void plant();
 9    
10    /** *//**
11     * 生长
12     */
13    void grow();
14}
15
16public class Apple implements IFruit {
17
18    public void grow() {
19        System.out.println("Apple grow()");
20    }
21
22    public void plant() {
23        System.out.println("Apple plant()");
24    }
25
26}
27
28public class Orange implements IFruit {
29
30    public void grow() {
31        System.out.println("Orange grow()");
32    }
33
34    public void plant() {
35        System.out.println("Orange plant()");
36    }
37
38}
39
40/** *//**
41 * 对应的字符串不存在的异常处理
42 */
43public class BadFruitException extends Exception {
44
45    public BadFruitException(String message) {
46        super(message);
47    }
48    
49}
50
51/** *//**
52 * 简单工厂类
53 */
54public class FruitGardener {
55    
56    public static IFruit factory(String which) throws BadFruitException {
57        if(which.equalsIgnoreCase("apple")) {
58            return new Apple();
59        } else if(which.equalsIgnoreCase("orange")) {
60            return new Orange();
61        } else {
62            throw new BadFruitException("bad fruit request");
63        }
64    }
65}
66
67/** *//**
68 * 测试简单工厂模式
69 */
70public class TestSimpleFactory {
71
72    public static void main(String[] args) {
73        try {
74            IFruit apple = FruitGardener.factory("apple");
75            apple.plant();
76            apple.grow();
77            
78            IFruit xx = FruitGardener.factory("xx");
79            xx.plant();
80            xx.grow();
81            
82        } catch (BadFruitException e) {
83            e.printStackTrace();
84        }
85    }
86}

三、分析
        1.从上面的例子可以看出：Simple Factory Pattern 就是由一个工厂类根据传入的参数来决定创建哪一种产品实例.
        2.Simple-Factory 涉及到3个角色：工厂类角色（Creator) 、抽象产品角色(Product)、具体产品角色(Concrete Product)
        3.优点：实现了对责任的分割 
           缺点：当产品需要扩展的时候，产品类直接没有影响，而工厂类就必须修改了~~ 因为工厂类涵盖了所有产品的创造逻辑
四：在java中的应用
        1.DateFormat
           （为一个抽象类，提供static  DateFormat getDateInstance()） : 这里可以粗略的看作 简单工厂类和抽象产品类的一个合并
            ---> 具体产品类SimpleDateFormat