工厂模式

1.简单工厂模式，简单粗暴，客户端只需要知道代表具体产品类的类型，通过简单工厂就能获取对象。 但是简单工厂违背了开放闭合原则，比如我需要加一个产品，就必须去改工厂类。示例：
产品抽象类：

private interface ICpu{
        void logCpu();
    }

    private interface IScreen{
        void logScreen();
    }

产品具体类：

    private static class InterCpu implements ICpu{
        @Override
        public void logCpu() {
            System.out.println("这是Inter的cpu");
        }
    }

    private static class InterScreen implements IScreen{

        @Override
        public void logScreen() {
            System.out.println("这是Inter的屏幕");
        }
    }

    private static class AMDCpu implements ICpu{
        @Override
        public void logCpu() {
            System.out.println("这是AMD的cpu");
        }
    }

    private static class AMDScreen implements IScreen{

        @Override
        public void logScreen() {
            System.out.println("这是AMD的屏幕");
        }
    }

简单工厂：

private static class CPUFactory{
        public static ICpu createCpu(int cpuType){
            switch (cpuType){
                case 1:
                    return new InterCpu();
                default:
                    return new AMDCpu();
            }
        }
    }

    private static class ScreenFactory{
        public static IScreen createScreen(int screenType){
            switch (screenType){
                case 1:
                    return new InterScreen();
                default:
                    return new AMDScreen();
            }
        }
    }

2.工厂模式，很好的解决了简单工厂的缺点，每一个产品都有它的工厂类，客户端只要知道产品对应的工厂类，就能创建对象， 新增产品也只需要新增工厂类，很容易拓展，缺点就是工厂太多,且一个产品族要客户自己去组装。示例：

private interface ICpuFactory{
        ICpu createCpu();
    }
    private interface IScreenFactory{
        IScreen createScreen();
    }
    private static class InterCpuFactory implements ICpuFactory{
        @Override
        public ICpu createCpu(){
            return new InterCpu();
        }
    }

    private static class InterScreenFactory implements IScreenFactory{
        @Override
        public IScreen createScreen(){
            return new InterScreen();
        }
    }

    private static class AMDCpuFactory implements ICpuFactory{
        @Override
        public ICpu createCpu(){
            return new AMDCpu();
        }
    }
    private static class AMDScreenFactory implements IScreenFactory{
        @Override
        public IScreen createScreen(){
            return new AMDScreen();
        }
    }

3.抽象工厂模式，适用于产品族（比如电脑由：CPU、主板、硬盘等组成，每一种电脑都是一个产品族），可以很方便的从一个产品族切到另一个产品族。产品族有固定的产品，工厂类提供了创建这些产品的方法，不同的产品族用不同的工厂类就行，缺点是不易拓展产品，加一个产品，所有产品族都得跟着变。示例：

private interface IComputerFactory{
        ICpu createCpu();
        IScreen createScreen();
    }

    private static class InterFactory implements IComputerFactory{

        @Override
        public ICpu createCpu() {
            return new InterCpu();
        }

        @Override
        public IScreen createScreen() {
            return new InterScreen();
        }
    }

    private static class AMDFactory implements IComputerFactory{

        @Override
        public ICpu createCpu() {
            return new AMDCpu();
        }

        @Override
        public IScreen createScreen() {
            return new AMDScreen();
        }
    }