通过让子类决定该创建的对象是什么，来达到将对象创建过程封装的目的。一般分为三类：简单工厂模式、工厂方法模式、抽象工厂模式
这里已缓存数据为例，缓存数据一般可在内存中缓存，SharedPreferences 中缓存，磁盘缓存等....
简单工厂模式
首先定义一个数据保存取出接口
public interface IOHandler {
void saveString(String key, String value);
String getString(String key, String defaultValue);
}
实现接口，书写具体的操作类
//实现接口，写具体的操作
public class SPHandler implements IOHandler {
@Override
public void saveString(String key, String value) {
//SPUtils 是封装的一个 SharedPreferences 工具类
SPUtils.getInstance().saveString(key, value).commit();
}
@Override
public String getString(String key, String defaultValue) {
return SPUtils.getInstance().getString(key, defaultValue);
}
}
书写Factory类，封装IOHandler 创建过程
public class IOHandlerFactory {
//定义一个枚举类，来区分该创建什么
public enum TYPE {
MEMORY, SHAREDPREFERENCES
}
public static IOHandler create(TYPE type) {
//根据不同的 type 创建不同的对象
switch (type) {
case MEMORY:
return new MemoryHandler();
case SHAREDPREFERENCES:
return new SPHandler();
default:
return new SPHandler();
}
}
}
在Activity中使用
class FactoryActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_factory)
//简单工厂模式
var ioHandler = IOHandlerFactory.create(IOHandlerFactory.TYPE.SHAREDPREFERENCES)
ioHandler.saveString("name", "liangshiguan")
ioHandler.saveString("age", "23")
factory_tv.setOnClickListener {
textClick()
}
}
private fun textClick() {
//简单工厂模式
var ioHandler = IOHandlerFactory.create(IOHandlerFactory.TYPE.SHAREDPREFERENCES)
var name = ioHandler.getString("name", "")
var age = ioHandler.getString("age", "")
factory_tv.setText("name------>" + name + " age------->" + age)
}
}
到这里，一个简单的工厂模式就写完了，如果我们需要修改保存的方式，不需要在重新new对象只需要修改TYPE。这样就不需要管对象的创建过程。然后这种模式还有一些不足：假如又增加了一种缓存方式，就需要在IOHandlerFactory中的枚举类中增加一个type，还需要在 create 方法中多增加一条 case，需要修改的有点多，所以出现下面这种写法
工厂方法模式
定义工厂需要的操作
public interface IOFactory {
IOHandler create();
}
定义SharedPreferences 的工厂，专门用来实例SPHandler对象
public class SPFactory implements IOFactory {
@Override
public IOHandler create() {
//直接实例化 SPHandler
return new SPHandler();
}
}
在Activity中使用变成
class FactoryActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_factory)
//工厂方法模式
var factory = SPFactory()
var ioHandler = factory.create()
ioHandler.saveString("name", "liangshiguan")
ioHandler.saveString("age", "23")
factory_tv.setOnClickListener {
textClick()
}
}
private fun textClick() {
//工厂方法模式
var factory = SPFactory()
var ioHandler = factory.create()
var name = ioHandler.getString("name", "")
var age = ioHandler.getString("age", "")
factory_tv.setText("name------>" + name + " age------->" + age)
}
}
这样，在增加新的缓存方式时，只需要增加对应的IOFactory子类和IOHandler子类就可以，而不需要修改原来的代码。然后这样子还是有一点不好，每增加一种方式就增加两个类，如果方式多了，类会变的很多，这样维护起来也很麻烦，所以又出现了下面的写法
抽象工厂模式
定义抽象工厂接口
public interface IOFactory {
IOHandler create(Class<? extends IOHandler> clazz);
}
书写工厂的实现类
public class IOHandlerFactory implements IOFactory {
//使用反射创建对象
@Override
public IOHandler create(Class<? extends IOHandler> clazz) {
try {
return clazz.newInstance();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
}
return new SPHandler();
}
//创建方法，获取getSPFactory 的对象
public IOHandler getSPFactory() {
return create(SPHandler.class);
}
public IOHandler getMemoryFactory() {
return create(MemoryHandler.class);
}
}
在Activity中使用
class FactoryActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_factory)
//抽象工厂
var ioHandler = IOHandlerFactory().memoryFactory
ioHandler.saveString("name", "liangshiguan")
ioHandler.saveString("age", "23")
factory_tv.setOnClickListener {
textClick()
}
}
private fun textClick() {
//抽象工厂
var ioHandler = IOHandlerFactory().memoryFactory
var name = ioHandler.getString("name", "")
var age = ioHandler.getString("age", "")
factory_tv.setText("name------>" + name + " age------->" + age)
}
}
这样，就可以少写一些 Factory 类（看起来和简单工厂每什么区别....）
