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

简单工厂

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

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

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

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

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

它的子类有东方剑EastSword

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

西洋剑 WesternSword

public class WesternSword extends Sword {@Overridepublic 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{@Overridepublic void produce() {System.out.println("produce a EastKnife");}
}public class EastSword extends Sword {@Overridepublic void produce() {System.out.println("produce a EastSword");}
}

和西洋的刀剑

public class WesternKnife extends Knife{@Overridepublic void produce() {System.out.println("produce a WesternKnife");}
}public class WesternSword extends Sword {@Overridepublic 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 EastSwordknife.produce();	// produce a EastKnife}
}

优点

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

缺点

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