GOF23种设计模式面试之三种工厂模式

简单工厂

简单工厂模式属于创建型模式，但是并不属于GOF23种设计模式，通过简单工厂模式，我们可以了解一下工厂模式相关的概念。

将实例化的操作放在一个类中，这个类就成为简单工厂类，简单工厂模式，定义了某一个工厂对象能够创建出哪一种产品类的实例。

借此将客户类和具体子类的实现进行解耦，客户端只注重于传入工厂类的参数，对于创建对象的逻辑不关心

---

例：
现在有一个抽象类Sword，可以打造各种剑

public abstract class Sword {
    public abstract void produce();
}

它的子类有东方剑EastSword

public class EastSword extends Sword{
    @Override
    public void produce() {
        System.out.println("produce a EastSword");
    }
}

西洋剑 WesternSword

public class WesternSword extends Sword {
    @Override
    public void produce() {
        System.out.println("produce a WestrnSword");
    }
}

现在准备打造剑：

如果这样打造的话，打造10种不同的剑则需要依赖10个不同的类

public class Client {
    public static void main(String[] args) {
        //Sword sword = new WesternSword();
        Sword sword = new EastSword();
        sword.produce();
    }
}

所以我们利用简单工厂的方式，只需要传递参数，让工厂来为我们生成对象，只需要依赖工厂这个类

//简单工厂
public class SwordSimpleFactory {
    public static Sword getSword(Class c){
        Sword sword = null;
        try {
            sword = (Sword) Class.forName(c.getName()).newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return sword;
    }
}
//对应的客户端
public class Client {
    public static void main(String[] args){
        //Sword sword = SwordSimpleFactory.getSword(WesternSword.class);
        Sword sword = SwordSimpleFactory.getSword(EastSword.class);
        sword.produce();
    }
}

优点：

• 只需要传入正确的参数，来获取需要的对象，而不需要了解创建的细节

缺点：

• 增加新的产品时，需要对工厂类的内部逻辑进行修改，违背了开闭原则

工厂方法

工厂方法定义了一个创建对象的接口，但由实现这个接口的子类决定要实例化哪个类，工厂方法把实例化操作推迟到子类。

例：
依旧是东方剑和西洋剑的例子

现在我们创建一个工厂的接口：SwordFactory，但是并不在这里实现创建对象的逻辑

public interface SwordFactory {
    Sword getSword();
}

创建对象的实现交给了该工厂的实现：EastFactory，WesternFactory

public class EastFactory implements SwordFactory{
    public Sword getSword() {
        return new EastSword();
    }
}

public class WesternFactory implements SwordFactory{
    public Sword getSword() {
        return new WesternSword();
    }
}

通过对应的工厂方法来生成对象

public class Client {
    public static void main(String[] args){
        //SwordFactory swordFactory = new WesternFactory();
        SwordFactory swordFactory = new EastFactory();
        Sword sword = swordFactory.getSword();
        sword.produce();
    }
}

这样不用在工厂里生成对应的逻辑，而是使用子类工厂创建对应的对象，符合开闭原则。当需要拓展生成新的对象，就实现一个新的子类工厂。

优点：

• 用户只需要关注产品对应的工厂，不用在意产品的创建细节
• 对于新产品的加入符合了开闭原则，提高可扩展性

缺点：

• 创建类的数量过多，会增加复杂度

抽象工厂

抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口，抽象工厂模式注重的是一个对象家族（产品族）。

该模式强调了一系列相关的产品对象（属于同一产品族）的生成，从一个产品族工厂取出来的产品一定属于同一产品族

---

产品族和产品等级结构

什么是产品族和产品等级结构？

例如：

刀和剑，是不同的产品，而东方刀和东方剑属于东方这一产品族，西洋刀和西洋剑属于西方的产品族。

而东方刀和西洋刀都是刀，属于同一产品等级结构，同理，东方剑和西洋剑也是同一产品等级结构。

而抽象工厂关心的就是产品族，比如对于上面的紫色图形，可以创建一个紫色工厂，该工厂可以生产紫色三角形，紫色圆形，紫色五边形。

例：
继续上面的例子

现在有了东方的刀剑

public class EastKnife extends Knife{
    @Override
    public void produce() {
        System.out.println("produce a EastKnife");
    }
}

public class EastSword extends Sword {
    @Override
    public void produce() {
        System.out.println("produce a EastSword");
    }
}

和西洋的刀剑

public class WesternKnife extends Knife{
    @Override
    public void produce() {
        System.out.println("produce a WesternKnife");
    }
}

public class WesternSword extends Sword {
    @Override
    public void produce() {
        System.out.println("produce a WestrnSword");
    }
}

定义一个抽象工厂：WeaponFactory 可以生产刀剑

public interface WeaponFactory {
    Sword getSword();
    Knife getKnife();
}

所以就有了东方武器工厂和西方武器工厂

//东方武器工厂
public class EastWeaponFactory implements WeaponFactory{
    public Sword getSword() {
        return new EastSword();
    }

    public Knife getKnife() {
        return new EastKnife();
    }
}

//西方武器工厂
public class WesternWeaponFactory implements WeaponFactory{
    public Sword getSword() {
        return new WesternSword();
    }

    public Knife getKnife() {
        return new WesternKnife();
    }
}

一个武器工厂，生产出来的产品一定是同一产品族的

public class Client {
    public static void main(String[] args){
        //WeaponFactory weaponFactory = new WesternWeaponFactory();
        WeaponFactory weaponFactory = new EastWeaponFactory();
        Sword sword = weaponFactory.getSword();
        Knife knife = weaponFactory.getKnife();
        sword.produce();	// produce a EastSword
        knife.produce();	// produce a EastKnife
    }
}

优点

• 将相关联的产品族统一到一个工厂内创建

缺点

• 工厂逻辑编写时就规定了所有产品集合，当需要在产品族中扩展新的产品时，则需要修改抽象工厂的接口