一、工厂模式概述
1、工厂设计模式将实例化对象的代码提取出来,进行统一的维护和管理,实现了对象实例化和程序逻辑的解耦,提高了项目的扩展性和可维护性。
2、工厂模式分为三种,即简单工厂模式、工厂方法模式和抽象工厂模式 。
3、工厂模式遵循了依赖抽象的原则。
二、工厂模式的实现
1、简单工厂模式
简单工厂模式属于创建型模式,是工厂模式的一种,是工厂模式中最简单实用的一种模式,它定义了一个封装了创建对象的方法的类。当需要大量的创建某类对象时,可以使用工厂模式。
//简单工厂类
public class SimpleFactory {
/**
* @Note {简单工厂模式 也叫 静态工厂模式
* 定义了一个创建对象的类,这个类封装了实例化对象的代码
* 根据orderType 返回对应的Pizza 对象
* }
* @author giserDev
* @Date 2020-05-10 18:59:39
*/
public static Pizza createPizza(String orderType) {
Pizza pizza = null;
System.out.println("使用简单工厂模式2");
if (orderType.equals("greek")) {
pizza = new GreekPizza();
pizza.setName(" 希腊披萨 ");
} else if (orderType.equals("cheese")) {
pizza = new CheesePizza();
pizza.setName(" 奶酪披萨 ");
} else if (orderType.equals("pepper")) {
pizza = new PepperPizza();
pizza.setName("胡椒披萨");
}
return pizza;
}
}
使用方法:
public class OrderPizza {
//定义一个简单工厂对象
SimpleFactory simpleFactory;
Pizza pizza = null;
//构造器
public OrderPizza(SimpleFactory simpleFactory) {
setFactory(simpleFactory);
}
public void setFactory(SimpleFactory simpleFactory) {
String orderType = ""; //用户输入的
this.simpleFactory = simpleFactory; //设置简单工厂对象
do {
orderType = getType();
pizza = this.simpleFactory.createPizza(orderType);
//输出pizza
if(pizza != null) { //订购成功
pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box();
} else {
System.out.println(" 订购披萨失败 ");
break;
}
}while(true);
}
// 写一个方法,可以获取客户希望订购的披萨种类
private String getType() {
try {
BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
System.out.println("input pizza 种类:");
String str = strin.readLine();
return str;
} catch (IOException e) {
e.printStackTrace();
return "";
}
}
}
2、工厂方法模式
当客户点Pizza时,可以点不同的Pizza,如北京的奶酪披萨、北京的胡椒披萨或伦敦的奶酪披萨、伦敦的胡椒披萨等时,可以使用工厂方法模式。即定义一个创建对象的抽象方法,由子类决定要实例化的类。工厂方法模式将对象的实例化推迟到子类。
public abstract class OrderPizza {
//定义一个抽象方法,createPizza , 让各个工厂子类自己实现
abstract Pizza createPizza(String orderType);
// 构造器
public OrderPizza() {
Pizza pizza = null;
String orderType; // 订购披萨的类型
do {
orderType = getType();
pizza = createPizza(orderType); //抽象方法,由工厂子类完成
//输出pizza 制作过程
pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box();
} while (true);
}
// 写一个方法,可以获取客户希望订购的披萨种类
private String getType() {
try {
BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
System.out.println("input pizza 种类:");
String str = strin.readLine();
return str;
} catch (IOException e) {
e.printStackTrace();
return "";
}
}
}
public class BJOrderPizza extends OrderPizza {
@Override
Pizza createPizza(String orderType) {
Pizza pizza = null;
if(orderType.equals("cheese")) {
pizza = new BJCheesePizza();
} else if (orderType.equals("pepper")) {
pizza = new BJPepperPizza();
}
return pizza;
}
}
public class LDOrderPizza extends OrderPizza {
@Override
Pizza createPizza(String orderType) {
Pizza pizza = null;
if(orderType.equals("cheese")) {
pizza = new LDCheesePizza();
} else if (orderType.equals("pepper")) {
pizza = new LDPepperPizza();
}
return pizza;
}
}
2、抽象工厂模式
抽象工厂模式定义了一个接口,用于创建相关的或有依赖关系的对象簇,将工厂抽象成两层:抽象工厂和具体实现的工厂子类。从设计层面看,抽象工厂模式是对简单工厂模式的进一步抽象,将单个工厂类变成了工厂簇,更利于代码的维护和扩展。
抽象工厂类:
/**
* @Note {定义一个抽象的工厂,由工厂子类实现}
* @author giserDev
* @Date 2020-05-10 20:15:02
*/
public interface AbsFactory {
public Pizza createPizza(String orderType);
}
工厂子类:
/**
* @Note {工厂子类}
* @author giserDev
* @Date 2020-05-10 20:16:05
*/
public class BJFactory implements AbsFactory {
@Override
public Pizza createPizza(String orderType) {
Pizza pizza = null;
if(orderType.equals("cheese")) {
pizza = new BJCheesePizza();
} else if (orderType.equals("pepper")){
pizza = new BJPepperPizza();
}
return pizza;
}
}
/**
* @Note {工厂子类}
* @author giserDev
* @Date 2020-05-10 20:16:05
*/
public class LDFactory implements AbsFactory {
@Override
public Pizza createPizza(String orderType) {
System.out.println("~使用的是抽象工厂模式~");
Pizza pizza = null;
if (orderType.equals("cheese")) {
pizza = new LDCheesePizza();
} else if (orderType.equals("pepper")) {
pizza = new LDPepperPizza();
}
return pizza;
}
}
使用工厂类
public class OrderPizza {
/**
* @Note {抽象工厂,用于接收具体的工厂子类}
* @author giserDev
* @Date 2020-05-10 20:18:34
*/
private AbsFactory factory;
public OrderPizza(AbsFactory factory) {
setFactory(factory);
}
private void setFactory(AbsFactory factory) {
Pizza pizza = null;
String orderType = ""; // 用户输入
this.factory = factory;
do {
orderType = getType();
// factory 可能是北京的工厂子类,也可能是伦敦的工厂子类
pizza = factory.createPizza(orderType);
if (pizza != null) { // 订购ok
pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box();
} else {
System.out.println("订购失败");
break;
}
} while (true);
}
// 写一个方法,可以获取客户希望订购的披萨种类
private String getType() {
try {
BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
System.out.println("input pizza 种类:");
String str = strin.readLine();
return str;
} catch (IOException e) {
e.printStackTrace();
return "";
}
}
}
测试:
public class PizzaStore {
public static void main(String[] args) {
// TODO Auto-generated method stub
new OrderPizza(new BJFactory());
// new OrderPizza(new LDFactory());
}
}
三、工厂模式的源码应用
Calendar类利用工厂模式实例化对象
Calendar c = Calendar.getInstance();
public static Calendar getInstance()
{
return createCalendar(TimeZone.getDefault(), Locale.getDefault(Locale.Category.FORMAT));
}
private static Calendar createCalendar(TimeZone zone,
Locale aLocale)
{
// 省略部分代码
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;
}
}
}
//省略部分代码
return cal;
}
四、总结
1、创建对象时,不要直接使用new,尽量利用工厂方法创建对象。即不要直接持有具体类的引用。
2、不要让类继承具体类,而是继承抽象类或者实现接口。
3、不要覆盖基类中已经实现的方法。