设计模式——工厂模式

工厂模式实现了创建者和调用者的分离。工厂模式的作用就是在实例化对象的时候代替了以往的new操作，将实现类、创建对象进行统一管理。详细分为：简单工厂模式、工厂方法模式、抽象工厂模式。使用工厂模式时最好要遵循面向对象设计的基本原则，即开闭原则、依赖倒转原则和迪米特法则。开闭原则：作为一个软件的应用程序的可扩展性，应当对扩展开放，对修改关闭。依赖倒转原则：要求要针对接口编程不要针对实现编程。迪米特法则：只与你有直接关系的进行沟通交流，而躲避那些陌生的和你不相干的，不与他们进行沟通交流。

简单工厂模式

下面我们先来说一下简单工厂模式，简单工厂模式当然实现起来是最简单的，下面我们以生产不同颜色的衣服为例：
工厂刚生产的布料还没有染色的时候

public interface Clothes {
    String color(String color);
}

准备将生产的一部分布料染成蓝色的

public class BlueClothes implements Clothes {
    @Override
    public String color(String color) {
        return color;
    }
}

准备将生产的一部分布料染成红色的

public class RedClothes implements Clothes {
    @Override
    public String color(String color) {
        return color;
    }
}

染色工厂进行分区

public class SimpleFactory {
    public static Clothes dyeingBlue(String product){
        return new BlueClothes();
    }
    public static Clothes dyeingRed(String product){
        return new RedClothes();
    }
}

最后工人开始对布料进行染色处理

 Clothes blueClothes = SimpleFactory.dyeingBlue("blue");
 Clothes redClothes = SimpleFactory.dyeingRed("red");
 blueClothes.color("蓝色");
 redClothes.color("红色");

以上是简单工厂的实现，但是此模式不遵循开闭原则，如果我们向生产黑色的衣服还需要在SimpleFactory 里面添加一个生产黑色衣服的方法，这样就违背了开闭原则的只扩展不修改。

工厂方法模式

它弥补了简单工厂模式的不满足开闭原则，工厂方法模式和简单工厂模式的不同之处在于，简单工厂模式只有一个工厂类也就是上面的SimpleFactory 这个类，而工厂方法模式是有一些实现了相同接口的工厂类。工厂方法模式的适用性：1.当一个类不知道它所必须创建的对象的类的时候。2.当一个类希望由它的子类来指定它所创建的对象的时候。3.当类将创建对象的职责委托给多个帮助子类中的某一个，并且你希望将哪一个帮助子类是代理者这一信息局部化的时候。
还以上面的例子为准，如果我们想增加一个黑色服装的加工怎么办？另开一个工厂加工黑色服装的，这样的话也方便各做各的事情

工厂刚生产的布料还没有染色的时候

public interface Clothes {
    String color(String color);
}

准备将生产的一部分布料染成蓝色的染料机器

public class BlueClothes implements Clothes {
    @Override
    public String color(String color) {
        return color;
    }
}

这里又专门增加一个工厂，专门生产蓝色服装的工厂

public class BlueClothesFactory implements ClothesFactory {
    @Override
    public Clothes dyeing(String color) {
        return new BlueClothes();
    }
}

准备将生产的一部分布料染成红色的染料机器

public class RedClothes implements Clothes {
    @Override
    public String color(String color) {
        return color;
    }
}

这里又专门增加一个工厂，专门生产红色服装的工厂

public class RedClothesFactory implements ClothesFactory {
    @Override
    public Clothes dyeing(String color) {
        return new RedClothes();
    }
}

如果想生产黑色的服装，很简单在开一个工厂和黑色的染料机器，下面的是黑色服装的染料机器

public class BlueClothes implements Clothes {
    @Override
    public String color(String color) {
        return color;
    }
}

生产黑色服装的加工工厂

public class BlackClothesFactory implements ClothesFactory {
    @Override
    public Clothes dyeing(String color) {
        return new BlackClothes();
    }
}

最后各个工厂开始加工生产服装

Clothes blueClothes = new BlueClothesFactory().dyeing("blue");
Clothes redClothes = new RedClothesFactory().dyeing("red");
Clothes blackClothes = new BlackClothesFactory().dyeing("black");
blueClothes.color("蓝色");
redClothes.color("红色");
blackClothes.color("黑色");

工厂方法模式的弊端结构复杂度比简单工厂模式要复杂一些，编程难度来说简单工厂模式的工厂类是个静态类，无需再编码中进行实例化，而工厂方法模式需要进行实例化，管理上的难度简单工厂模式要比工厂方法模式容易的多，虽然设计的理念是工厂方法模式，但是在实际的开发过程中我们一般还是使用的简单工厂模式。

抽象工厂模式

抽象工厂模式是工厂方法的升级版，它是用来生产不同产品集合的全部产品。在有多个产品的分类时，抽象工厂模式产生需要的对象是一种很好的解决方式。它的操作主要是提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。适用性1.一个系统要独立于它的产品的创建、组合和表示时。2.一个系统要由多个产品系列中的一个来配置时。3.当你要强调一系列相关的产品对象的设计以便进行联合使用时。4.当你提供一个产品类库，而只想显示它们的接口而不是实现时。
比如我们使用的手机，手机都是有摄像头，手机屏，内存等等组合而成。那么摄像头，手机屏，cpu就属于不同的种类，那么就要分别进行加工生产，然后再进行拼装。但是不同的手机的质量有好有坏，好的手机当然配置也是很高档的，如果本来是五千的手机，配置跟五百的手机一样谁会去买五千的手机呢？嫌钱多烫手的例外。
生产屏幕

public interface Screen {
    String clarity(String clarity);

    class HighGrade implements Screen {

        @Override
        public String clarity(String clarity) {
            return clarity;
        }
    }
    class Bastard implements Screen {

        @Override
        public String clarity(String clarity) {
            return clarity;
        }
    }
}

生产摄像头

public interface Camera{
    String pixel(String pixel );

    class HighDefinition implements Camera {

        @Override
        public String pixel (String pixel ) {
            return pixel ;
        }
    }
    class General implements Camera {

        @Override
        public String pixel(String pixel ) {
            return pixel ;
        }
    }
}

生产内存

public interface Memory{
String storage(String storage);
class Large implements Memory{

    @Override
    public String storage(String storage) {
        return storage;
    }
}
class Small implements Memory{

    @Override
    public String storage(String storage) {
        return storage;
    }
}
}

手机工厂

public interface PhoneFactory{
    Screen productScreen();
    Camera productCamera();
    Memory productMemory();
}

专门生产高配置的工厂

public class HighWithFactory implements PhoneFactory{

    @Override
    public Screen productScreen() {
        return new Screen.HighGrade();
    }

    @Override
    public Camera productCamera() {
        return new Camera.HighDefinition();
    }

    @Override
    public Memory productMemory() {
        return new Memory.Large();
    }
}

加工产品

PhoneFactory phoneFactory = new HighWithFactory();
Camera camera = phoneFactory.productCamera();
camera.pixel("像素高");
Memory memory = phoneFactory.productMemory();
memory.storage("内存大");
Screen screen = phoneFactory.productScreen();
screen.clarity("高清");

到这里关于工厂的一些模式已经介绍完了，这里再总结一下，简单工厂模式又叫静态工厂模式，虽然不符合开闭原则，但是使用者还是最多。工厂方法模式在不修改已有类的情况下，通过增加新的工厂类来实现扩展。抽象工厂不能增加产品，但是可以增加产品的类型集合。比如我们的手机就是一个产品，而摄像头就是一个产品类型的集合。