列子;不同的吃厂商需要不同的UI,进行打包
一般是结合泛型来用。
- 松耦合,调用方只需与工厂类交互,无需关心实例怎么创建的。
- 扩展性强,只需新增一个实现类和修改工厂方法即可,这也算缺点的一方面。
首先先介绍一下标准的工厂方法模式,不带任何的变种.以工厂生产不同操作系统的手机为例.
/***工厂模式的生产*/ public void factoryMode(){ try{ Iphone androidPhone=PhoneGeneratorFactory.createPhone(PhoneGeneratorFactory.GENERATE_ANDROID); }catch (Exception e){ } }
/**正常流程*/ public void NomalMode(){ try{ Iphone android, ios, bb; IGenerator androidGenerator, iosGenerator, bbGenerator; androidGenerator = new AndroidGenerator(); iosGenerator = new IosGenerators(); bbGenerator = new WindowGenerator(); android = androidGenerator.generatePhone(PhoneGeneratorFactory.GENERATE_ANDROID); ios = iosGenerator.generatePhone(PhoneGeneratorFactory.GENERATE_IOS); bb = bbGenerator.generatePhone(PhoneGeneratorFactory.GENERATE_Window); android.getOS(); ios.getOS(); bb.getOS(); }catch (Exception e){ } }
/** * 静态方法 * 只需要知道要生产什么型号的手机:苹果手机 * * * @param flag * @return * @throws Exception */ public static Iphone createPhone(String flag) throws Exception { Iphone iPhone = null; switch (flag){ case GENERATE_ANDROID: iPhone = new AndroidPhone(); break; case GENERATE_IOS: iPhone = new IosPhone(); break; case GENERATE_Window: iPhone = new WindowPhone(); break; default: throw new Exception("UNDEFINED FLAG"); } return iPhone; } /** * 静态方法 * 只需要知道要生产什么型号的手机:苹果手机 * 升级版 * * @param flag * @return * @throws Exception */ public static Iphone createPhonePlus(String flag) throws Exception { Iphone iPhone = null; switch (flag){ case GENERATE_ANDROID: iPhone = new AndroidGenerator().generatePhone(GENERATE_ANDROID); break; case GENERATE_IOS: iPhone = new IosGenerators().generatePhone(GENERATE_IOS); break; case GENERATE_Window: iPhone = new WindowGenerator().generatePhone(GENERATE_Window); break; default: throw new Exception("UNDEFINED FLAG"); } return iPhone; } //抽象类可以只实现抽象类的部分方法 /**如果这个抽象类继承了别的抽象类,那么可以不覆盖抽象方法。 因为:这个抽象类也是抽象的,没办法实现方法体。*/ //有2种方式,实现类要实现抽象类的所有方法 abstract class PhoneGeneratorAbstract extends IGenerator { public <T extends Iphone>T generatePhone(Class<T> clazz) throws Exception { Iphone iPhone = null; iPhone = (Iphone) Class.forName(clazz.getName()).newInstance(); return (T)iPhone; } } //有2种方式,实现类要实现抽象类的所有方法 class PhoneGenerator extends IGenerator { public <T extends Iphone>T generatePhone(Class<T> clazz) throws Exception { Iphone iPhone = null; iPhone = (Iphone) Class.forName(clazz.getName()).newInstance(); return (T)iPhone; } @Override public Iphone generatePhone(String flag) throws Exception { return null; } }
/** * Created by Administrator on 2017/9/12. * 不同的工厂生产不同的产品 */ public class AndroidGenerator extends IGenerator { @Override public Iphone generatePhone(String flag) throws Exception { return new AndroidPhone(); } }
public class IosGenerators extends IGenerator { @Override public Iphone generatePhone(String flag) throws Exception { return new IosPhone(); } }
public class WindowGenerator extends IGenerator { @Override public Iphone generatePhone(String flag) throws Exception { return new WindowPhone(); } }
public abstract class IGenerator { public abstract Iphone generatePhone(String flag) throws Exception; /**泛型,抽象接口*/ public abstract <T extends Iphone>T generatePhone(Class<T> clazz) throws Exception; }
源码:不知道为什么上传不了
总结:
1.一个接口封装方法
2.多个实现类继承借口,重写接口里面的方法
3.一个工具类,封装静态方法,可以调用
好处:不需要知道具体的过程,只需要给一个型号,工厂就自动生产(
客户端不再创建对象,而是把创建对象的职责交给了具体的工厂去创建
)
降低了对象之间的耦合度,代码结构清晰
,对调用者隐藏了产品的生产过程,生产过程改变后,调用者不用做什么改变,易于修改。
BitMapFactory:
线程池:
Excutors里面的就是工程模式,
工厂方法提供的5种不同的线程池
public static ExecutorService newFixedThreadPool(int nThreads) { return new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>()); }