设计模式-工厂模式

简单工厂（静态工厂）

​ 简单工厂模式是属于创建型模式，又叫做静态工厂方法模式，但不属于23种GOF设计模式之一。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式，可以理解为是不同工厂模式的一个特殊实现。

代码例子：

// 抽象产品角色
public interface People {
    String sayName();
}

// 具体产品角色 张三
public class Zhangsan implements People{
    @Override
    public String sayName() {
        return "张三";
    }
}

// 具体产品角色 李四
public class Lisi implements People{
    @Override
    public String sayName() {
        return "李四";
    }
}

// 工厂角色
public class PeopleFactory {

    public static People getZhangsan(){
        return new Zhangsan();
    }

    public static People getLisi(){
        return new Lisi();
    }
}

// 客户端
public class Main {
    public static void main(String[] args) {
        People zhangsan = PeopleFactory.getZhangsan();
        People lisi = PeopleFactory.getLisi();
        System.out.println(zhangsan.sayName());
        System.out.println(lisi.sayName());
    }
}

在代码中出现了几个角色，分别是抽象产品角色、具体产品角色、工厂角色。

• 抽象产品角色：就是产品的抽象，将产品的共性抽取出来，例如人会说话，会走路，会吃饭；交通工具会动，会有喇叭等等。在实际系统中抽象产品角色会被定义为接口或抽象类。
• 具体产品角色：就是抽象产品的实现或扩展，例如人，有哪些是人，张三、李四；交通工具，有哪些是交通工具，汽车、火车、飞机等。
• 工厂角色：就是负责产品的生产工作。在简单工厂模式中，工厂类是一个具体的实现类，在系统设计中工厂类负责实际对象的创建工作。它知道系统中都存在哪些能够创建对象的具体类，也知道该如何将创建的对象，以某种能够屏蔽具体类实现细节的方式提供给所需要的其他角色来使用该对象提供的数据和服务。

工厂方法

​ 工厂方法是简单工厂的衍生，解决了许多简单工厂的问题，完全实现开闭原则，实现了可扩展。其次更复杂的层次结构，可以应用于产品结果复杂的情况。工厂方法就是对简单工厂进行了抽象。有一个抽象的Factory类（可以是抽象类或接口），这个类不在负责具体产品的生产，而只是制定一些规范，具体的生产工作由子类去完成。在这个模式中，工厂类和产品类往往可以依次对应。即一个抽象工厂对应一个抽象产品，一个具体工厂对应一个具体产品，这个具体的工厂就负责生产对应的产品。

代码例子：

// 抽象产品角色
public interface People {
    String sayName();
}

// 具体产品角色 张三
public class Zhangsan implements People{
    @Override
    public String sayName() {
        return "张三";
    }
}

// 具体产品角色 李四
public class Lisi implements People{
    @Override
    public String sayName() {
        return "李四";
    }
}

// 抽象工厂
public interface PeopleFactory {
    People create();
}

// 具体工厂 张三
public class ZhangsanFactory implements PeopleFactory{
    @Override
    public People create() {
        return new Zhangsan();
    }
}

// 具体工厂 李四
public class LisiFactory implements PeopleFactory{
    @Override
    public People create() {
        return new Lisi();
    }
}

// 客户端
public class Main {
    public static void main(String[] args) {
        PeopleFactory zhangsanFactory = new ZhangsanFactory();
        PeopleFactory lisiFactory = new LisiFactory();
        People zhangsan = zhangsanFactory.create();
        People lisi = lisiFactory.create();
        System.out.println(zhangsan.sayName());
        System.out.println(lisi.sayName());
    }
}

• 抽象工厂：是工厂方法的核心，与应用程序无关。任何在模式中创建的对象的工厂类必须实现这个接口。 　
• 具体工厂：这是实现抽象工厂接口的具体工厂类，包含与应用程序密切相关的逻辑，并且受到应用程序调用以创建产品对象。
• 抽象产品：工厂方法所创建的对象的超类，也就是产品对象的共同父类或共同拥有的接口。
• 具体产品：这个角色实现了抽象产品角色所定义的接口。某具体产品有专门的具体工厂创建，它们之间往往一一对应。

抽象工厂

​ 抽象工厂是所有形态的工厂中最为抽象和最具一般性的一种形态。抽象工厂是指当有多个抽象角色时，使用的一种工厂模式。抽象工厂可以向客户端提供一个接口，使客户端在不必指定产品的具体的情况下，创建多个产品族中的产品对象。

代码例子：

// 抽象产品 食物
public interface Food {
    String getName();
}

// 抽象产品 工具
public interface Tool {
    String getName();
}

// 具体产品 食物
public class Bread implements Food{
    @Override
    public String getName() {
        return "面包";
    }
}
public class Milk implements Food{
    @Override
    public String getName() {
        return "牛奶";
    }
}
public class Noodles implements Food{
    @Override
    public String getName() {
        return "面条";
    }
}

// 具体产品 工具
public class Straw implements Tool{
    @Override
    public String getName() {
        return "吸管";
    }
}
public class Knife implements Tool{
    @Override
    public String getName() {
        return "餐刀";
    }
}
public class Chopsticks implements Tool{
    @Override
    public String getName() {
        return "筷子";
    }
}

// 抽象工厂 吃东西
public abstract class EatFoodFactory {
    abstract Food getFood();

    abstract Tool getTool();
}

// 具体工厂 吃中餐
public class ChineseFoodFactory extends EatFoodFactory{
    @Override
    Food getFood() {
        return new Noodles();
    }

    @Override
    Tool getTool() {
        return new Chopsticks();
    }
}

//具体工厂 吃西餐
public class WesternFoodFactory extends EatFoodFactory{
    @Override
    Food getFood() {
        return new Bread();
    }

    @Override
    Tool getTool() {
        return new Knife();
    }
}

//具体工厂 吃东餐
public class EastFoodFactory extends EatFoodFactory{
    @Override
    Food getFood() {
        return new Milk();
    }

    @Override
    Tool getTool() {
        return new Straw();
    }
}

​ 抽象工厂为创建一组对象提供了一种解决方案。 与工厂方法相比， 抽象工厂中的具体工厂不只是创建一种具体对象，它负责创建一组（族）具体对象。

​ 当我们有一系列产品。而这一系列产品每种产品又需要具有不同的创建方法时就可以使用抽象工厂来实现。