工厂模式(Factory)

工厂模式.png

定义：定义一个创建产品对象的工厂接口，将实际创建工作推迟到具体的子工厂类中，将对象的创建与使用分离，也正是遵循了依赖倒转原则。

工厂模式的三种不同实现方式：

简单工厂模式（静态工厂方法模式）
工厂方法模式
抽象工厂模式

简单工厂模式（静态工厂方法模式）

优点：

工厂和产品职责分明。
客户端无需知道具体类名，直接通过参数让工厂提供想要的产品。

缺点：

工厂类单一，负责所有产品的创建，一旦工厂类异常，会影响其它产品的创建。
当需要增加产品种类的时候，需要修改代码，违反开闭原则。
判断逻辑会随着产品种类变多变得越来越复杂，代码臃肿。

package com.yang.factory;

public class Client {
    public static void main(String[] args) {
        Product product = SimpleFactory.makeProduct(1);
        assert product != null;
        product.show();
    }

    //抽象产品
    public interface Product {
        void show();
    }

    //具体产品：ProductA
    static class ConcreteProduct1 implements Product {
        public void show() {
            System.out.println("具体产品1显示...");
        }
    }

    //具体产品：ProductB
    static class ConcreteProduct2 implements Product {
        public void show() {
            System.out.println("具体产品2显示...");
        }
    }

    final class Const {
        static final int PRODUCT_A = 0;
        static final int PRODUCT_B = 1;
    }

    static class SimpleFactory {
        public static Product makeProduct(int kind) {
            switch (kind) {
                case Const.PRODUCT_A:
                    return new ConcreteProduct1();
                case Const.PRODUCT_B:
                    return new ConcreteProduct2();
            }
            return null;
        }
    }
}

工厂方法模式

对简单工厂的进一步抽象

优点：

找对应工厂生产对应产品，无需了解生产细节
增加新产品只需增加对应的工厂类，无需修改源码，遵循开闭原则
解耦

缺点：

类的数量多，增肌复杂度
增加系统抽象性，加大理解难度
一个工厂只能生产一种产品

package com.yang.factory.methodFactory;

//抽象产品：提供产品生产细节
public interface IphoneInterface {
    void print();
}

package com.yang.factory.methodFactory;

//具体产品：电池
public class Battery implements IphoneInterface {

    @Override
    public void print() {
        System.out.println("电池生产完成");
    }
}

package com.yang.factory.methodFactory;

//具体产品：屏幕
public class Screen implements IphoneInterface {
    @Override
    public void print() {
        System.out.println("显示屏生产完成");
    }
}

package com.yang.factory.methodFactory;

//抽象工厂：提供了产品的生产方法
public interface IphoneAbstractFactory {
    public IphoneInterface newIphoneFitting();
}

package com.yang.factory.methodFactory;
//具体工类厂：生产电池
public class BatteryFactory implements IphoneAbstractFactory {
    @Override
    public IphoneInterface newIphoneFitting() {
        System.out.println("电池配件工厂开工-->生产电池");
        return new Battery();
    }
}

package com.yang.factory.methodFactory;

//具体工厂类 生产显示屏
public class ScreenFactory implements IphoneAbstractFactory {
    @Override
    public IphoneInterface newIphoneFitting() {
        System.out.println("显示屏工厂开工-->生产显示屏");
        return new Screen();
    }
}

抽象工厂模式

提供生产一组具有相关性或者依赖性对象的接口，调用者不需要指定对象具体实现类，就可以得到同族的不同产品。

是工厂方法模式的升级版

优点：

将具有相关性的产品放在同一工厂加工，减少类的数量。
当需要产品族时，抽象工厂可以保证客户端始终只使用同一个产品的产品组。
抽象工厂增强了程序的可扩展性，当增加一个新的产品族时，不需要修改原代码。

缺点：

当同一种族需要添加新产品时，显得不灵活，需要修改源码。
增加了系统的抽象性和理解难度。

在工厂方法模式的基础上修改代码：

package com.yang.factory.abstractmethodFactory;

//抽象工厂：提供了手机各个配件生产方法
public interface IphoneAbstractFactory {

    public IphoneInterface newBattery();

    public IphoneInterface newScreen();

}

package com.yang.factory.abstractmethodFactory;

public class IphoneAbstractFactoryImpl implements IphoneAbstractFactory {
    @Override
    public IphoneInterface newBattery() {
        System.out.println("电池配件工厂开工-->生产电池");
        return new Battery();
    }

    @Override
    public IphoneInterface newScreen() {
        System.out.println("显示屏工厂开工-->生产显示屏");
        return new Screen();
    }
}

package com.yang.factory.abstractmethodFactory;

public class Test {
    public static void main(String[] args) {
        IphoneAbstractFactory iphoneAbstractFactory = new IphoneAbstractFactoryImpl();
        iphoneAbstractFactory.newBattery().print();
        iphoneAbstractFactory.newScreen().print();
    }
}

电池配件工厂开工-->生产电池
电池生产完成
显示屏工厂开工-->生产显示屏
显示屏生产完成