1.什么是工厂设计模式？
工厂设计模式，说白了，就是用来生产对象的，在java中，万物皆对象，这些对象都需要创建，如果创建的时候直接new该对象，就会对该对象耦合严重，假如我们要更换对象，所有new对象的地方都需要修改一遍，这显然违背了Java六大基本原则的开闭原则，如果我们使用工厂来生产对象，我们就只和工厂打交道就可以了，彻底和对象解耦，如果要更换对象，直接在工厂类里更换该对象即可，达到了与对象解耦的目的；所以说，工厂模式最大的优点就是：解耦
2.工厂设计模式的分类
2.1 简单工厂模式
2.2 工厂方法模式
2.3 抽象工厂模式
简单工厂模式:
定义：通过类型来创建对象。
数据存储获取接口
public interface IOHandler {
//*************** 保存数据 ****************
void save(String key,String value);
//*************** 获取数据 ****************
String getString(String key);
}
具体类 ：MemoryIOHandler(内存存储)
/**
* 内存存数数据MemoryIOHandler
*/
public class MemoryIOHandler implements IOHandler {
//存在运行内存里面，原理是什么？ 起始就是Map集合 应用退出这些数据就没有
private static LruCache<String,Object> mCache = new LruCache<>(10 * 1024 * 1024);
@Override
public void save(String key, String value) {
mCache.put(key,value);
}
//********** 获取数据 *************
@Override
public String getString(String key) {
return (String) mCache.get(key);
}
}
具体类 ：PreferencesIOHandler(SP存储)
/**
* SharedPreferences进行存储
*/
public class PreferencesIOHandler implements IOHandler {
@Override
public void save(String key, String value) {
//封装成工具类
SPutils.getInstance().saveString(key,value).commit();
}
@Override
public String getString(String key) {
return SPutils.getInstance().getString(key);
}
}
具体工厂
public class IOHandlerFactory {
public enum IOType{
MEMORY,PREFERENCES
}
/**
* 创建对应的对象
* @param ioType
* @return
*/
public static IOHandler createFactory(IOType ioType){
switch (ioType){
case MEMORY:
return new MemoryIOHandler();
case PREFERENCES:
return new PreferencesIOHandler();
default:
return null;
}
}
}
使用：
//保存数据
IOHandler ioHandler = IOHandlerFactory.createFactory(IOHandlerFactory.IOType.MEMORY);
ioHandler.save("userName","姚明");
ioHandler.save("password","123456");
//获取数据
IOHandler ioHandler = IOHandlerFactory.createFactory(IOHandlerFactory.IOType.MEMORY);
String userName = ioHandler.getString("userName");
String passWord = ioHandler.getString("password");
tv.setText("userName :"+userName +"---- passWord :"+passWord);
简单工厂类图：
image.png
一个非常简单的工厂设计模式就完成了，但是有没有发现什么问题呢？
当我们想要换一种存储方式的时候，就必然要修改我们的工厂类，违反了我们的开闭原则。所以简单工厂适用于产品固定需求，对于变换无常的可能就不太合适了。
缺点：每次添加其他存储方式都需要创建对象，还要添加case 语句进行创建
方法工厂模式：
定义：每一个工厂对应一个需要创建的对象，工厂类进行创建对象初始化
在我们的简单工厂上进行修改
工厂接口
public interface IOFactory {
//创建我们的存储方式
IOHandler createIOHandler();
}
MemoryIOFactory 工厂
public class MemoryIOFactory implements IOFactory {
@Override
public IOHandler createIOHandler() {
return new MemoryIOHandler();
}
}
PreferencesIOHandler 工厂
public class PreferencesIOFactory implements IOFactory {
@Override
public IOHandler createIOHandler() {
return new PreferencesIOHandler();
}
}
使用：
//保存数据
IOFactory ioFactory = new MemoryIOFactory();
IOHandler ioHandler = ioFactory.createIOHandler();
ioHandler.save("userName","姚明");
ioHandler.save("password","123456");
//获取数据
IOFactory ioFactory = new MemoryIOFactory();
IOHandler ioHandler = ioFactory.createIOHandler();
String userName = ioHandler.getString("userName");
String passWord = ioHandler.getString("password");
tv.setText("userName :"+userName +"---- passWord :"+passWord);
工厂方法类图：
image.png
缺点：随着业务不断的增加，Factory类不断的增加，代码大多都相同，造成代码的冗余
抽象工厂模式
定义：抽象工厂和简单工厂有点类似，将所有的创建提取出来接口，通过实现接口自己去创建。
public interface IOFactory {
/**
* 创建 数据存储工厂
* @param ioHandler
* @return
*/
IOHandler createIOHandler(Class<? extends IOHandler> ioHandler);
/**
* 获取内存存储对象
* @return
*/
IOHandler getMemoryIOHandler();
/**
* 获取SP存储对象
* @return
*/
IOHandler getPreferencesIOHandler();
/**
* 获取默认存储对象
* @return
*/
IOHandler getDefaultIOHandler();
}
public class IOHandlerFactory implements IOFactory{
private static volatile IOHandlerFactory mInstance;
private IOHandler mMemoryHandler,mPreferencesHandler,mDefaultHandler;
private IOHandlerFactory() {
}
public static IOHandlerFactory getInstance(){
if (mInstance == null){
synchronized (IOHandlerFactory.class){
if (mInstance == null){
mInstance = new IOHandlerFactory();
}
}
}
return mInstance;
}
/**
* 创建我们的IOHandler，通过类反射创建
* @param ioHandler
* @return
*/
@Override
public IOHandler createIOHandler(Class<? extends IOHandler> ioHandler) {
try {
return ioHandler.newInstance();
} catch (Exception e) {
e.printStackTrace();
}
//给一个默认的Preferences
return new PreferencesIOHandler();
}
@Override
public IOHandler getMemoryIOHandler() {
if (mMemoryHandler == null){
return createIOHandler(MemoryIOHandler.class);
}
return mMemoryHandler;
}
@Override
public IOHandler getPreferencesIOHandler() {
if (mPreferencesHandler == null){
return createIOHandler(PreferencesIOHandler.class);
}
return mPreferencesHandler;
}
@Override
public IOHandler getDefaultIOHandler() {
if (mDefaultHandler == null){
return createIOHandler(PreferencesIOHandler.class);
}
return mDefaultHandler;
}
}
使用：
//保存数据
IOHandler ioHandler = IOHandlerFactory.getInstance().getMemoryIOHandler();
ioHandler.save("userName","闫长辉111");
ioHandler.save("password","123456");
//获取数据
IOHandler ioHandler = IOHandlerFactory.getInstance().getMemoryIOHandler();
String userName = ioHandler.getString("userName");
String passWord = ioHandler.getString("password");
tv.setText("userName :"+userName +"---- passWord :"+passWord);
抽象工厂类图
image.png
总结：
1、对于简单工厂和工厂方法来说，两者的使用方式基本上是一样的，如果对于产品的存储方式是确定的，数量是相对固定的，推荐使用简单工厂模式。
2、抽象工厂用来解决相对复杂的问题，适用于一系列、大批量的对象生产。
网友评论