工厂模式

一、概述

工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

简单理解就是把所有的对象扔到一个容器中，想要什么就直接从里面拿到即可。

二、简单工厂

接口

public interface Colors {
    void display();
}

实现类

Blue

public class Blue implements Colors {
    @Override
    public void display() {
        System.out.println("我是蓝色");
    }
}

Red

public class Red implements Colors{
    @Override
    public void display() {
        System.out.println("我是红色");
    }
}

简单工厂

public class ColorSimpleFactory {
    public static Colors getColor(String color){
        if(color.equalsIgnoreCase("blue")){
            return new Blue();
        }else if(color.equalsIgnoreCase("red")){
            return new Red();
        }else {
            return null;
        }
    }
}

这样的话，如果我们想要得到一个对象不需要new

Colors blue= ColorSimpleFactory.getColor("blue");

但是这样做的话，我们要知道简单工厂里面有哪些类可以供我们使用，而且每增加一个类，都要在工厂里面加入新的类，而且还要知道传入什么参数才能去得到这个对象，使用起来具有一定的局限性。

注意：简单工厂不属于设计模式的一种

三、工厂方法

工厂方法我们可以定义成一个接口，也可以定义成一个抽象类

定义的工厂抽象类

public interface ColorMethodFactory {
     Colors getColor();
}

接口实现

public class BlueFactory implements ColorMethodFactory {
    @Override
    public Colors getColor() {
        return new Blue();
    }
}

简单调用

Colors blue = new BlueFactory().getColor();

这种方式，我们不像简单工厂那样，每次新添一个对象，都需改写内部方法。只需继承ColorMethodFactory接口，为新的对象单独新建一个工厂。但是这样做有一个弊端：当对象很多时，就会造成类的泛滥，因为每个对象都要为其建立一个工厂。

四、抽象工厂

抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。

提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

案例

下面我们单独的以电脑加工厂为例，实现抽象工厂。

创建接口

首先我们要明确电脑加工厂要具有加工配件和品牌的特性

// 生产配件的接口
public interface Compoents {
    void created();
}

// 打印品牌
public interface Computer{
    void printBrand();
}

Compoents实现类

public class KeyBoard implements Compoents {
    @Override
    public void created() {
        System.out.println("生产键盘");
    }
}

public class Mouse implements Compoents {
    @Override
    public void created() {
        System.out.println("生产鼠标");
    }
}

Computer实现类

public class DellComputer implements Computer {
    @Override
    public void printBrand() {
        System.out.println("戴尔电脑厂商");
    }
}

public class LenovoComputer implements Computer {
    @Override
    public void printBrand() {
        System.out.println("联想电脑厂商");
    }
}

工厂接口

public interface ComputerFactory {
    Compoents createdMouse();

    Compoents createdKeyBoard();

    Compoents createdScreen();

    Computer getBrand();
}

创建Dell加工厂

public class DellFactory implements ComputerFactory {
    @Override
    public Compoents createdMouse() {
        return new Mouse();
    }

    @Override
    public Compoents createdKeyBoard() {
        return new KeyBoard();
    }

    @Override
    public Compoents createdScreen() {
        return new Screen();
    }

    @Override
    public Computer getBrand() {
        return new DellComputer();
    }
}

测试

ComputerFactory factory = new DellFactory();
factory.getBrand().printBrand();
// 电脑键盘
factory.createdKeyBoard().created();
// 电脑鼠标
factory.createdMouse().created();
factory.createdScreen().created();

[外链图片转存失败(img-GZ4LBCf6-1568618182583)(https://i.imgur.com/tfim5SM.jpg)]

这种方式我们可以看到把对象的创建，对象的行为完全解耦合。如果我们想新添加个电脑配件，只需实现Compoents这个接口，添加到工厂接口中即可。如果想新加一个对象实现Computer接口。想配置电脑工厂可以生产什么，继承ComputerFactory接口即可。

源码：
https://github.com/Black1499/DesignPattern/tree/master/src/com/lzx/pattern/factory