设计模式-工厂模式

1、工厂模式简介

定义：属于创建型设计模式，在工厂模式中，创建对象不会对用户暴漏创建的逻辑，通过一个共同的接口返回创建的对象

使用场景：创建复杂的对象

目标：定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。

解决问题：解决接口选择问题

说明：按照业务场景可分为三类：简单（静态）工厂模式、工厂模式、抽象工厂模式

2、简单（静态）工厂模式

定义：有一个工厂类，可以产出不同类型的产品，但是当增加一个产品则需要增加一个具体的产品类和一个工厂类，违背了开闭原则

角色：简单工厂（check）、抽象产品（staticCar）、具体产品（staticCar、staticBus）

优点：用户无需知道所创建具体产品的类名，只需知道材料（参数）即可

　　   工厂类包含必要的逻辑判断，可以决定在什么时候创建哪一个产品的实例

缺点：简单工厂模式的工厂类单一，负责所有产品的创建，职责过重，一旦异常，整个系统将受影响

　　   使用简单工厂模式会增加系统中类的个数（引入新的工厂类），增加系统的复杂度和理解难度

　　　简单工厂模式使用了 static 工厂方法，造成工厂角色无法形成基于继承的等级结构

实现：

public class staticFactory {
    /**
     * 工厂接口
     */
    public interface staticCar{
        void show();
    }

    /**
     * 产品1
     */
    static class Bus implements staticCar{

        @Override
        public void show() {
            System.out.println("This is a static Bus");
        }
    }

    /**
     * 产品2
     */
    static class Taxi implements staticCar{

        @Override
        public void show() {
            System.out.println("This is a static Taxi");
        }
    }


    public static class check  {
        /**
         * 判断返回哪个产品的对象
         * @param kind
         * @return
         */
         static staticCar checkFactory(int kind) {
            switch (kind) {
                case 1:
                    return new Bus();
                case 2:
                    return new Taxi();
            }
            return null;
        }
    }
}

3、工厂模式

定义：工厂模式是对简单工厂模式的进一步抽象，增加新的产品不需要修改原来的代码，符合开闭原则

角色：具体工厂（CarFactory）、抽象产品（Car）、具体产品（Bus、Taxi）

优点：户只需要知道具体工厂的名称就可得到所要的产品，无须知道产品的具体创建过程

　　　灵活性增强，对于新产品的创建，只需多写一个相应的工厂类

　　　典型的解耦框架。高层模块只需要知道产品的抽象类，无须关心其他实现类，满足迪米特法则、依赖倒置原则和里氏替换原则

缺点：类的个数容易过多，增加复杂度

　　　增加了系统的抽象性和理解难度

　　　抽象产品只能生产一种产品，此弊端可使用抽象工厂模式解决

实现：

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

//具体产品A
public class Bus implements Car{
    @Override
    public void show() {
        System.out.println("This is a Bus");
    }
}

//具体产品B
public class Taxi implements Car  {
    @Override
    public void show() {
        System.out.println("This is a Taxi");
    }
}

//具体工厂
public class CarFactory {
    public Car checkCar(String kind){
        if("".equals(kind)){
            return null;
        }
        System.out.println("工厂开始生产"+kind+"产品");
        switch (kind){
            case "bus":
                return new Bus();

            case "taxi":
                return new Taxi();
        }
        return  null;
    }
}

//测试代码
public  class Test {
    public static void main(String[] args) {
        String kind = "bus";
        Car car = new CarFactory().checkCar(kind);
        System.out.println("========================");
        car.show();
    }
}
//测试结果
工厂开始生产bus产品
========================
This is a Bus

4、抽象工厂模式

定义：一种为访问类提供一个创建一组相关或相互依赖对象的接口，且访问类无须指定所要产品的具体类就能得到同族的不同等级的产品的模式结构，属于工厂模式的升级，工厂模式中只能生产同级产品，而抽象工厂模式能生产多级产品

角色：抽象产品（Car、Color）、具体产品（Bus、Taxi、Red、Black）、抽象工厂（AbstractFactory）、扩展抽象工厂（ACheckFactory、BCheckFactory）

优点：可以在类的内部对产品族中相关联的多等级产品共同管理，而不必专门引入多个新的类来进行管理

　　　当需要产品族时，抽象工厂可以保证客户端始终只使用同一个产品的产品组

　　　抽象工厂增强了程序的可扩展性，当增加一个新的产品族时，不需要修改原代码，满足开闭原则

缺点：当新增加产品时，所有的工厂类都需要更改

实现：

//抽象产品A
public interface Car {
    void show();
}
//具体产品A1
public class Bus implements Car {
    @Override
    public void show() {
        System.out.println("This is a abstract Bus");
    }
}
//具体产品A2
public class Taxi implements Car {
    @Override
    public void show() {
        System.out.println("This is a abstract Taxi");
    }
}

//抽象产品B
public interface Color{
    void showColor();
}
//抽象产品B1
public class Red implements Color {
    @Override
    public void showColor() {
        System.out.println("This color is red");
    }

}
//抽象产品B2
public class Black implements Color {
    @Override
    public void showColor() {
        System.out.println("This color is black");
    }
}

//抽象工厂
public abstract class AbstractFactory {
    public abstract Car getCar();
    public abstract Color getColor();
}
//扩展抽象工厂A
public class ACheckFactory extends AbstractFactory{
    @Override
    public Car getCar() {
        System.out.println("A市abstract工厂开始生产Car类产品");
        return new Bus();
    }

    @Override
    public Color getColor() {
        System.out.println("A市abstract工厂开始生产Color类产品");
        return new Red();
    }

    public void speak(){
        System.out.println("A市产品好，欢迎来购买");
    }
}
//扩展抽象工厂B
public class BCheckFactory extends AbstractFactory{
    @Override
    public Car getCar() {
        System.out.println("B市abstract工厂开始生产Car类产品");
        return new Taxi();
    }

    @Override
    public Color getColor() {
        System.out.println("B市abstract工厂开始生产Color类产品");
        return new Black();
    }

    public void speak(){
        System.out.println("B市产品棒，欢迎来选购");
    }
}

//测试方法
public  class Test {
    public static void main(String[] args) {
        System.out.println("=========A市工厂开始生产===========");
        AbstractFactory abstractFactory = new ACheckFactory();
        Color AColor = abstractFactory.getColor();
        Car ACar = abstractFactory.getCar();
        AColor.showColor();
        ACar.show();
        ((ACheckFactory) abstractFactory).speak();

        System.out.println("=========B市工厂开始生产===========");
        AbstractFactory bbstractFactory = new BCheckFactory();
        Color BColor = bbstractFactory.getColor();
        Car BCar = bbstractFactory.getCar();
        BColor.showColor();
        BCar.show();
        ((BCheckFactory) bbstractFactory).speak();

    }
}
//测试结果
=========A市工厂开始生产=====================
A市abstract工厂开始生产Color类产品
A市abstract工厂开始生产Car类产品
This color is red
This is a abstract Bus
A市产品好，欢迎来购买
=========B市工厂开始生产=====================
B市abstract工厂开始生产Color类产品
B市abstract工厂开始生产Car类产品
This color is black
This is a abstract Taxi
B市产品棒，欢迎来选购