设计模式-JDK工厂模式
目录
一、基本简介
工厂方法模式(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;
}
本文地址:https://blog.csdn.net/weixin_37645032/article/details/110000224
上一篇: 设计模式之—桥接模式
下一篇: 游戏福利系统设计实践