• 松耦合，调用方只需与工厂类交互，无需关心实例怎么创建的。
• 扩展性强，只需新增一个实现类和修改工厂方法即可，这也算缺点的一方面。

/***工厂模式的生产*/
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;
}

public static ExecutorService newFixedThreadPool(int nThreads) {return new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>());
}