最近在学习一些设计模式,原本想着既然有轮子了,那就直接拿过来用,但是看了很多篇博客,很多都是雷同的(不会都是土豆这货写的吧,三本书一个模式),我对代码有一定的洁癖,代码能优化就一定要优化,就打算写篇博客,方便自己查看
我所知道的Fragment工厂类大致有以下几种
-
第一种
这种写法大伙肯定看到过,这种写法我觉的不好的地方是:调用者每次调用方法的时候还要点进去看,看每个postion分别对应什么,还要看每个if else
private static SparseArray<Fragment> mFragments = new SparseArray<>();
public static Fragment createFragment(int position) {
Fragment fragment = null;
fragment = mFragments.get(position); //在集合中取出来Fragment
if (fragment == null) //如果在集合中没有取出来，需要重新创建
{
if (position == 0) {
// fragment = new ProxyFragment();
} else if (position == 1) {
// fragment = new ObservableFragment();
} else if (position == 2) {
// fragment = new PayFragment();
}
if (fragment != null) {
mFragments.put(position, fragment);
}
}
return fragment;
}
-
第二种
根据静态常量去区分对应的Fragment,这种也是网上出现最多的一种,对比第一种,可以很方便的找到需要返回的fragment,这种还可以继续优化,让参数做限制
private static Map<Integer, Fragment> mFragments = new HashMap<Integer, Fragment>();
public static final int PROXY_FRAGMENT = 0;
public static final int PAY_FRAGMENT = 1;
public static final int OBSERVABLE_FRAGMENT = 2;
public static Fragment createFragment(int position) {
Fragment fragment = null;
fragment = mFragments.get(position); //在集合中取出来Fragment
if (fragment == null) //如果在集合中没有取出来，需要重新创建
{
if (position == PROXY_FRAGMENT) {
fragment = new ProxyFragment();
} else if (position == PAY_FRAGMENT) {
fragment = new ObservableFragment();
} else if (position == OBSERVABLE_FRAGMENT) {
fragment = new PayFragment();
}
if (fragment != null) {
mFragments.put(position, fragment);
}
}
return fragment;
}
-
第三种
有人可能会有疑问,枚举不是影响性能吗,你还用枚举,对于这个,我只能说,请您看下图
are you kidding
private static final Map<FragmentType, Fragment> sFragmentMap = new HashMap<>();
public static Fragment createFragment(FragmentType type) {
// TODO: 2018/3/24 打印日志,引用的是第三方的类库, 您可以换成你自己的
Logger.d(sFragmentMap.toString());
if (sFragmentMap.containsKey(type)) {
return sFragmentMap.get(type);
}
Fragment fragment = null;
switch (type) {
case PAY_FRAGMENT:
fragment = new PayFragment();
break;
case PROXY_FRAGMENT:
fragment = new ProxyFragment();
break;
case OBSERVABLE_FRAGMENT:
fragment = new ObservableFragment();
break;
}
sFragmentMap.put(type, fragment);
return fragment;
}
public enum FragmentType {
PAY_FRAGMENT, // 支付
PROXY_FRAGMENT, // 代理
OBSERVABLE_FRAGMENT // 观察者
}
-
第四种
这种方法,我之前也纠结了好久,因为枚举影响性能,所以我之前写的都是第三种,直到看到这篇博客:https://blog.csdn.net/baidu_18607183/article/details/46369407(里面有一句话说的很对)反射大概比直接调用慢50~100倍，但是需要你在执行100万遍的时候才会有所感觉,判断一个函数的性能，你需要把这个函数执行100万遍甚至1000万遍,如果你只是偶尔调用一下反射，请忘记反射带来的性能影响,如果你需要大量调用反射，请考虑缓存。
你的编程的思想才是限制你程序性能的最主要的因素
private static Map<Class<? extends Fragment>, Fragment> sFragmentMap = new HashMap<>();
public static Fragment createFragment(Class<? extends Fragment> clazz) {
// TODO: 2018/3/24 打印日志,引用的是第三方的类库, 您可以换成你自己的
Logger.d(sFragmentMap.toString());
if (sFragmentMap.containsKey(clazz)) {
return sFragmentMap.get(clazz);
}
try {
Fragment fragment = clazz.newInstance();
sFragmentMap.put(clazz, fragment);
return fragment;
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
throw new NullPointerException("fragment is not exist");
}
