#工厂模式

什么是工厂模式？

一般我们在创建对象时是通过new关键字来实例化对象，而工厂模式就是用工厂方法代替new操作来创建对象的一种模式。

工厂模式有三种：简单工厂模式、工厂方法模式和抽象工厂模式

在学习这三种工厂模式前，先来看一个小故事。你是一个水果商人，负责加工各种水果然后出售，但是由人工手动加工效率太慢，于是乎你决定开一家水果工厂，由工厂负责加工水果，然后你在出售。在这个故事中，水果就是对象，由工厂来负责创建。

简单工厂模式

SingleFactor 是一个生产水果的工厂，它的createFruit()用来生产水果实例。具体代码如下：

水果类

public interface Fruit {
     void talk();
}

class Apple implements Fruit{
    private String name;
    public Apple(String name){
        this.name=name;
    }
    @Override
    public void talk() {
        System.out.println(name+"生产成功");
    }
}
class Banana implements Fruit{
    private String name;
    public Banana(  String name){
        this.name=name;
    }
    @Override
    public void talk() {
        System.out.println(name+"生产成功");
    }
}
class Pear implements Fruit{
    private String name;
    public Pear( String name){
        this.name=name;
    }
    @Override
    public void talk() {
        System.out.println(name+"生产成功");
    }
}

工厂类

public class SingleFactor {
    private  Fruit fruit;
    public SingleFactor(){

    }
    public  Fruit createFruit(Class  classz){
        if (classz.equals(Apple.class)){
            fruit=new Apple("富士康Apple");
            System.out.println("开始生产富士康Apple");
        }else if (classz.equals(Banana.class)){
            fruit=new Banana("加拿大Banana");
            System.out.println("开始生产加拿大Banana");
        }else if (classz.equals(Pear.class)){
            fruit=new Pear("天山雪梨");
            System.out.println("开始生产天山雪梨");
        }else {
            System.out.println("生产失败");
        }
        return fruit;
    }
}

一切准备就绪，开始加工水果了

public class Main {
    public static void main(String[] args) {
      SingleFactor factor=new SingleFactor();
      Fruit fruit = factor.createFruit(Apple.class);
      fruit.talk();

    }
}

以上就是简单工厂模式的代码。

简单工厂模式的优缺点

优点：将对象的创建与使用分离开来，降低代码的耦合性
**缺点：**如果我们想生产新的水果，需要在SingleFactor 里面再添多个if-else,扩展性差。

工厂方法模式

简单工厂模式的缺点来源于我们把各种对象的生产挤在一个类中，如果有一种方法能把不同的类的生产放在不同的工厂，一个工厂专门负责生产一个类的对象，那么生产的秩序是不是就清新许多了呢？如果这时候还有新的类的对象需要生产，那就开开辟一个工厂就好了，扩展就方便许多了。
工厂方法模式的定义为：定义一个用于创建对象的接口或抽象类，让子类决定实例化哪一个类。

其中，Fruit接口及其子类的代码不变，增加了一个抽象工厂AbstractFactory，里面定义了一个生产水果的方法 createFruit()，具体创造什么类型的水果由其子工厂实现。

抽象工厂类及其子工厂类如下：

public interface AbstractFactory {
   
}
class AppleFactory implements AbstractFactory{
    @Override
    public Fruit createFruit() {
        return new Apple("富士康Apple");
    }
}
class BananaFactory implements AbstractFactory{
    @Override
    public Fruit createFruit() {
        return new Banana("加拿大Banana");
    }
}
class PearFactory implements AbstractFactory{
    @Override
    public Fruit createFruit() {
        return new Pear("天山雪梨");
    }
}

测试方法Main

public class Main {
    public static void main(String[] args) {
      AppleFactory factory=new AppleFactory();
        Fruit fruit = factory.createFruit();
        fruit.talk();
    }
}

工厂方法模式的优缺点
优点： 扩展性强，可维护性高。
**缺点：**新增一个类就要新增一个工厂，那新增10W个类就要新增10W个工厂，这显然是不划算的。

抽象工厂模式

在工厂方法模式中，一个具体的工厂负责生产一类具体的产品，即一对一的关系，而抽象工厂模式就可以实现一个工厂，生产多种产品对象。

抽象工厂我们定义了两个方法，createRipeFruit() 和 createGreenFruit()用来表示生产成熟水果和未熟水果，同时我们定义了三个子工厂用来创建不同成熟度的水果，这三个子工厂重写了父类工厂的两个方法。我们就以Apple为例

Fruit 接口及它的实现类：

public interface Fruit {
     void talk();
}

interface Apple extends Fruit{
    @Override
    public void talk();
}
class GreenApple implements Apple{
    private String name;
    public GreenApple(String name){
        this.name=name;
    }
    @Override
    public void talk() {
        System.out.println(name);
    }
}
class RedApple implements Apple{
    private String name;
    public RedApple(String name){
        this.name=name;
    }
    @Override
    public void talk() {
        System.out.println(name);
    }
}
.............................................

工厂代码

public abstract class AbstractFactory {
    abstract Fruit createRipeFruit();
    abstract Fruit createGreenFruit();
}
class AppleFactory extends AbstractFactory{
    private Fruit fruit;
    @Override
    Fruit createRipeFruit() {
       fruit=new RedApple("富士康红Apple");
       return fruit;
    }

    @Override
    Fruit createGreenFruit() {
        fruit=new GreenApple("龙湖青Apple");
        return fruit;
    }
}
...............................

测试类

public class Main {
    public static void main(String[] args) {
        AppleFactory factory=new AppleFactory();
        Fruit greenApple = factory.createGreenFruit();
        greenApple.talk();
    }
}

抽象工厂与工厂方法的对比：

抽象工厂与工厂方法最终都是创建对象，但方式有所不同，工厂方法采用的是继承，抽象工厂采用的是组合。而抽象工厂中蕴含着很多的工厂方法，而工厂方法是创建单个产品，抽象工厂是创建整个产品家族，所以说抽象工厂中蕴含着工厂方法。

来源：设计模式篇——工厂模式详解