设计模式学习－工厂模式

1.定义

定义一个创建对象的接口，但让实现这个接口的类来决定实例化哪个类。工厂方法让类的实例化推迟到子类中进行。

2.类图

3.代码示例

package com.zhaoyangwoo.factorymethod;

/**
 * Created by john on 16/5/1.
 * @author wuzhaoyango
 * <p>
 *     This is a demo for factoryMethod
 * </p>
 * <p>
 *     工厂方法：一抽象产品类派生出多个具体产品类；一抽象工厂类派生出多个具体工厂类；每个具体工厂类只能创建一个具体产品类的实例。
 *     即定义一个创建对象的接口（即抽象工厂类），让其子类（具体工厂类）决定实例化哪一个类（具体产品类）。“一对一”的关系。
 * </p>
 */
public class FactoryMethod {

    private static Factory factoryA,factoryB;
    private static Product productA,productB;
    public static void main(String[] args) {
        factoryA = new FactoryA();
        factoryB = new FactoryB();
        productA = factoryA.create();
        productB = factoryB.create();
        productA.getName();
        productB.getName();
    }
}


interface Product{
    void getName();
}

interface Factory{
    Product create();
}

class ProductA implements Product{

    @Override
    public void getName() {
        System.out.println("I'm productA");
    }
}

class ProductB implements Product{

    @Override
    public void getName() {
        System.out.println("I'm productB");
    }
}

class FactoryA implements Factory {

    @Override
    public Product create() {
        return new ProductA();
    }
}

class FactoryB implements Factory {

    @Override
    public Product create() {
        return new ProductB();
    }
}

4.扩展：简单工厂模式

　　4.1 类图

　　

　　4.2 代码示例

　　

package com.zhaoyangwoo.simplefactory;

/**
 * Created by john on 16/5/1.
 * 简单工厂实现类,ConcreteFactory是"上帝类",这个设计模式是工厂方法的一种扩展,实际使用也比较多,但是
 * 它并不满足开闭原则,如果拓展类一种新的产品,例如ProductC,那么必须修改create方法的判断条件,别无他法.
 * 这并无影响它的广泛使用,所以原则是死的,编码是活的. 
 */
public class SimpleFactory {
    public static void main(String[] args){
        Product product = ConcreteFactory.create(ProductA.class);
        product.getName();
    }
}

class ConcreteFactory {
    public static Product create(Class t) {
        if(t.equals(ProductA.class)){
            return new ProductA();
        }else if(t.equals(ProductB.class)){
            return new ProductB();
        }else {
            throw new IllegalArgumentException("参数错误");
        }
    }
}
interface Product{
    void getName();
}

class ProductA implements Product {

    @Override
    public void getName() {
        System.out.println("I'm productA");
    }
}

class ProductB implements Product {

    @Override
    public void getName() {
        System.out.println("I'm productB");
    }
}

5.应用场景举例

• 创建复杂对象，隔离对象创建的具体过程
• 一个类不知道它所需要的对象的类：客户端不需要知道具体产品类的类名，只需要知道所对应的工厂即可，具体的产品对象由具体工厂类创建；客户端需要知道创建具体产品的工厂类。 

6.JDK源码中的模式实现

还记得我们在单例模式中提到的Calendar.getInstance() 吗？它实际上就是工厂方法的一个典型实现。我们再来看看源码

 public static Calendar getInstance(TimeZone zone,
                                       Locale aLocale)
    {
        return createCalendar(zone, aLocale);
    }

    private static Calendar createCalendar(TimeZone zone,
                                           Locale aLocale)
    {
        CalendarProvider provider =
                LocaleProviderAdapter.getAdapter(CalendarProvider.class, aLocale)
                        .getCalendarProvider();
        if (provider != null) {
            try {
                return provider.getInstance(zone, aLocale);
            } catch (IllegalArgumentException iae) {
                // fall back to the default instantiation
            }
        }

        Calendar cal = null;

        //通过判断条件来决定用怎样的子类来实例化父类
        if (aLocale.hasExtensions()) {
            String caltype = aLocale.getUnicodeLocaleType("ca");
            if (caltype != null) {
                switch (caltype) {
                    case "buddhist":
                        cal = new BuddhistCalendar(zone, aLocale);
                        break;
                    case "japanese":
                        cal = new JapaneseImperialCalendar(zone, aLocale);
                        break;
                    case "gregory":
                        cal = new GregorianCalendar(zone, aLocale);
                        break;
                }
            }
        }

        //通过判断条件来决定用怎样的子类来实例化父类
        if (cal == null) {
            if (aLocale.getLanguage() == "th" && aLocale.getCountry() == "TH") {
                cal = new BuddhistCalendar(zone, aLocale);
            } else if (aLocale.getVariant() == "JP" && aLocale.getLanguage() == "ja"
                    && aLocale.getCountry() == "JP") {
                cal = new JapaneseImperialCalendar(zone, aLocale);
            } else {
                cal = new GregorianCalendar(zone, aLocale);
            }
        }
        return cal;
    }

再举一个例子 NumberFormat.getInstance(),我们继续看源码

    public final static NumberFormat getInstance() {
        return getInstance(Locale.getDefault(Locale.Category.FORMAT), NUMBERSTYLE);
    }
    private static NumberFormat getInstance(Locale desiredLocale,
                                           int choice) {
        LocaleProviderAdapter adapter;
        adapter = LocaleProviderAdapter.getAdapter(NumberFormatProvider.class,
                                                   desiredLocale);
        NumberFormat numberFormat = getInstance(adapter, desiredLocale, choice);
        if (numberFormat == null) {
            numberFormat = getInstance(LocaleProviderAdapter.forJRE(),
                                       desiredLocale, choice);
        }
        return numberFormat;
    }


    private static NumberFormat getInstance(LocaleProviderAdapter adapter,
                                            Locale locale, int choice) {
        NumberFormatProvider provider = adapter.getNumberFormatProvider();
        NumberFormat numberFormat = null;
        switch (choice) {
        case NUMBERSTYLE:
            numberFormat = provider.getNumberInstance(locale);
            break;
        case PERCENTSTYLE:
            numberFormat = provider.getPercentInstance(locale);
            break;
        case CURRENCYSTYLE:
            numberFormat = provider.getCurrencyInstance(locale);
            break;
        case INTEGERSTYLE:
            numberFormat = provider.getIntegerInstance(locale);
            break;
        }
        return numberFormat;
    }

 

7.思考

• 我们是否有必要将简单工厂/工厂方法/抽象工厂区分开来？

        我的想法是不用。要知道其实这三个设计模式的形式都是极为相似的：将实例化动作交给子类来达到解耦的目的。另外工厂方法中用静态方法＋判断代替抽象类即可转化为简单工厂。如果工厂方法中的产品不止一个，即增加一个产品，产生了产品蔟的概念，那么也就轻松转化成了抽象工厂。所以我认为实际使用中，不要太在意使用了哪个工厂。

• 产品能否是其本身？

        当然可以！单例模式其实就是工厂方法最极端的情况。

//1.简单工厂的实现
class ConcreteFactory {
    public static Product create(Class t) {
        if(t.equals(ProductA.class)){
            return new ProductA();
        }else if(t.equals(ProductB.class)){
            return new ProductB();
        }else {
            throw new IllegalArgumentException("参数错误");
        }
    }
}
//2.将工厂作为产品.看出来没,单例的雏形已经出来了
class ConcreteFactory {
    public static ConcreteFactory create() {
       return new ConcreteFactory();
    }
}

8.参考

1.设计模式（二）工厂方法模式
2.技术之大，在乎你我心中