列子;不同的吃厂商需要不同的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>()); }