设计模式-JDK工厂模式

目录

一、基本简介

二、优缺点

1、优点

2、缺点

三、应用场景

四、代码示例

示例1：

示例2：

五、JDK工厂模式

1、Collection中的iterator方法

2、Calendar创建实例

---

一、基本简介

工厂方法模式（Factory Method），定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法模式使一个类的实例化延迟到其子类。

二、优缺点

1、优点

（1）良好的封装性、代码结构清晰。

如一个调用者想创建一个对象，只需要知道其名称即可，降低了模板间的耦合。

（2）扩展性好。

如果想增加一个产品，只需扩展一个工厂类即可。

（3）屏蔽产品类

调用者只关心产品的接口。

（4）典型的解耦框架

2、缺点

每增加一个产品，就需要增加一个产品工厂的类，增加了系统的复杂度。

三、应用场景

1、何时使用

不同条件下创建不用实例时。方法是让子类实现工厂接口。

2、使用场景

• 创建对象需要大量重复的代码。
• 创建对象需要访问某些信息，而这些信息不应该包含在复合类中。
• 创建对象的生命周期必须集中管理，以保证在整个程序中具有一致的行为。

3、应用实例

（1） 需要一辆汽车，直接从工厂里面提货，不用去管这辆车是怎么做出来的。

（2）hibernate换数据库只需换方言和驱动即可。

（3）简单计算器的实现。

四、代码示例

示例1：

1、Factory类

public abstract class Factory {
    public abstract Product createProduct(String owner);
    public abstract void registerProduct(Product p);
    public abstract void getAllProductOwner();
    public Product create(String owner){
        Product p = createProduct(owner);
        registerProduct(p);
        return p;
    }
}

 2、IDCardFactory类

import java.util.ArrayList;
import java.util.List;

public class IDCardFactory extends Factory {
    List owners = new ArrayList();
    public Product createProduct(String owner){
        System.out.println("为 "+owner+" 创造产品成功...");
        return new IDCardProduct(owner);
    }

    @Override
    public void registerProduct(Product p) {
        String owner=((IDCardProduct)p).getOwner();
        owners.add(owner);
        System.out.println("注册 "+owner+" 的产品成功...");
    }

    @Override
    public void getAllProductOwner() {
        for(int i=0;i<owners.size();i++){
            System.out.println("产品用户："+owners.get(i));
        }
    }
}

3、抽象类 

public abstract class Product {
    public abstract void use();
}

4、 具体实现类

public class IDCardProduct extends Product {
    String owner;

    public IDCardProduct(String owner) {
        this.owner = owner;
    }

    @Override
    public void use() {
        System.out.println("用户 "+owner+" 正在使用产品...");
    }

    public String getOwner() {
        return owner;
    }
}

5、测试类

public class FactoryMain {
    public static void main(String[] args) {
        Factory f = new IDCardFactory();
        Product p = f.create("张三");
        p.use();
        System.out.println("--------------------");
        p = f.create("李四");
        p.use();
        System.out.println("--------------------");
        f.getAllProductOwner();
    }
}

6、控制台输出

示例2：

工厂接口：

/**
 * 抽象工厂接口
 */
public interface IWorkFactory {
    /**
     * 定义获取Work实例对象的方法
     * @return
     */
    Work getWork();
}

工厂具体实现：

/**
 * IWorkFactory工厂的实现类
 *
 */
public class StudentWorkFactory implements IWorkFactory {
	@Override
    public Work getWork() {
        return new StudentWork();
    }
}

/**
 * IWorkFactory工厂的实现类
 */
public class TeacherWorkFactory implements IWorkFactory {
	@Override
    public Work getWork() {
        return new TeacherWork();
    }
}

product产品类：

public interface Work {
    /**
     * 定义方法
     */
    void doWork();
}

产品生产类：

/**
 *  Work接口的具体实现类
 *
 */
public class TeacherWork implements Work {
    @Override
    public void doWork() {
        System.out.println("老师审批作业!");
    }
}

/**
 * Work接口的具体实现类
 */
public class StudentWork implements Work {
	   @Override
    public void doWork() {
        System.out.println("学生做作业!");
    }
} 

测试类：

/**
 * 测试类
 *
 */
public class FactoryTest {
    public static void main(String[] args) {
        IWorkFactory studentWorkFactory = new StudentWorkFactory();
        studentWorkFactory.getWork().doWork();
        IWorkFactory teacherWorkFactory = new TeacherWorkFactory();
        teacherWorkFactory.getWork().doWork();
    }
}

 

五、JDK工厂模式

1、Collection中的iterator方法

java.util.Collection接口中定义了一个抽象的iterator()方法，该方法就是一个工厂方法。

对于iterator()方法来说Collection就是一个根抽象工厂，下面还有List等接口作为抽象工厂，再往下有ArrayList等具体工厂;

java.util.Iterator接口是根抽象产品，下面有ListIterator等抽象产品，还有ArrayListIterator等作为具体产品;

使用不同的具体工厂类中的iterator方法能得到不同的具体产品的实例;

2、Calendar创建实例

Calendar calendar = Calendar.getInstance();

public static Calendar getInstance() {
    Locale aLocale = Locale.getDefault(Category.FORMAT);
    return createCalendar(defaultTimeZone(aLocale), 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 var7) {
        }
    }

    Calendar cal = null;
    if (aLocale.hasExtensions()) {
        String caltype = aLocale.getUnicodeLocaleType("ca");
        if (caltype != null) {
            byte var6 = -1;
            switch(caltype.hashCode()) {
            case -1581060683:
                if (caltype.equals("buddhist")) {
                    var6 = 0;
                }
                break;
            case -752730191:
                if (caltype.equals("japanese")) {
                    var6 = 1;
                }
                break;
            case 283776265:
                if (caltype.equals("gregory")) {
                    var6 = 2;
                }
            }

            switch(var6) {
            case 0:
                cal = new BuddhistCalendar(zone, aLocale);
                break;
            case 1:
                cal = new JapaneseImperialCalendar(zone, aLocale);
                break;
            case 2:
                cal = new GregorianCalendar(zone, aLocale);
            }
        }
    }

    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 (Calendar)cal;
}