工厂模式
前言
在编程中,构建对象最常用的方式是 new 一个对象。其实构建过程可以被封装起来,工厂模式便是用于封装对象的设计模式。
简单工厂模式
比如,直接 new 对象的方式相当于当我们需要一个苹果时,我们需要知道苹果的构造方法,需要一个梨子时,需要知道梨子的构造方法。更好的实现方式是有一个水果工厂,我们告诉工厂需要什么种类的水果,水果工厂将我们需要的水果制造出来给我们就可以了。这样我们就无需知道苹果、梨子是怎么种出来的,只用和水果工厂打交道即可。
水果工厂代码:
public class FruitFactory {
public Fruit create(String type) {
switch (type) {
case "apple":
return new Apple();
case "pear":
return new Pear();
default:
throw new IllegalArgumentException("do not have this fruit!");
}
}
}
调用者代码:
public class User {
private void eat() {
FruitFactory fruitFactory = new FruitFactory();
Fruit apple = fruitFactory.create("apple");
Fruit pear = fruitFactory.create("pear");
apple.eat();
pear.eat();
}
}
将构建过程封装的好处不仅可以降低耦合,如果某个产品构造方法相当复杂,使用工厂模式可以大大减少代码重复。比如,如果生产一个苹果需要苹果种子、阳光、水分,将工厂修改如下:
public class FruitFactory {
public Fruit create(String type) {
switch (type) {
case "apple":
AppleSeed appleSeed = new AppleSeed();
Sunlight sunlight = new Sunlight();
Water water = new Water();
return new Apple(appleSeed, sunlight, water);
case "pear":
return new Pear();
default:
throw new IllegalArgumentException("do not have this fruit!");
}
}
}
调用者的代码则完全不需要变化,而且调用者不需要在每次需要苹果时,自己去构建苹果种子、阳光、水分以获得苹果。苹果的生产过程再复杂,也只是工厂的事。这就是封装的好处,假如要将肥料加入苹果的生产过程中的话,也只需要在工厂中修改。
简单工厂模式就是让一个工厂类承担构建所有对象的职责。调用者需要什么产品,让工厂生产出来即可。它的弊端:
1、如果需要生产的产品过多,此模式会导致工厂类过于庞大,承担过多的职责,变成超级类。当苹果生产过程需要修改时,要来修改此工厂。梨子生产过程需要修改时,也要来修改此工厂。也就是说这个类不止一个引起修改的原因。违背了单一职责原则。
2、当要生产新的产品时,必须在工厂类中添加新的分支。而开闭原则告诉我们:类应该对修改封闭。我们希望在添加新功能时,只需增加新的类,而不是修改既有的类,所以这就违背了开闭原则。
工厂方法模式
为了解决简单工厂模式的这两个弊端,工厂方法模式应运而生,它规定每个产品都有一个专属工厂。比如苹果有专属的苹果工厂,梨子有专属的梨子工厂,代码如下:
public class AppleFactory {
public Fruit create() {
return new Apple();
}
}
public class PearFactory {
public Fruit create() {
return new Pear();
}
}
调用者代码:
public class User {
private void eat() {
AppleFactory appleFactory = new AppleFactory();
Fruit apple = appleFactory.create();
PearFactory pearFactory = new PearFactory();
Fruit pear = pearFactory.create();
apple.eat();
pear.eat();
}
}
当构建过程相当复杂时,工厂将构建过程封装起来,调用者可以很方便的直接使用,举个栗子:
public class AppleFactory {
public Fruit create() {
AppleSeed appleSeed = new AppleSeed();
Sunlight sunlight = new Sunlight();
Water water = new Water();
return new Apple(appleSeed, sunlight, water);
}
}
调用者无需知道苹果的生产细节,当生产过程需要修改时也无需更改调用者。同时,工厂方法模式解决了简单工厂模式的两个弊端:
1、当生产的产品种类越来越多时,工厂类不会变成超级类。工厂类会越来越多,保持灵活。不会越来越大、变得臃肿。如果苹果的生产过程需要修改时,只需修改苹果工厂。梨子的生产过程需要修改时,只需修改梨子工厂。符合单一职责原则。
2、当需要生产新的产品时,无需更改既有的工厂,只需要添加新的工厂即可。保持了面向对象的可扩展性,符合开闭原则。
抽象工厂模式
工厂方法模式可以进一步优化,提取出工厂接口:
public interface IFactory {
Fruit create();
}
分别实现此接口:
public class AppleFactory implements IFactory {
@Override
public Fruit create() {
return new Apple();
}
}
public class PearFactoryimplements IFactory {
@Override
public Fruit create() {
return new Pear();
}
}
调用者可以将 AppleFactory 和 PearFactory 统一作为 IFactory 对象使用,代码如下:
public class User {
private void eat() {
IFactory appleFactory = new AppleFactory();
Fruit apple = appleFactory.create();
IFactory pearFactory = new PearFactory();
Fruit pear = pearFactory.create();
apple.eat();
pear.eat();
}
}
可以看到,我们在创建时指定了具体的工厂类后,在使用时就无需再关心是哪个工厂类,只需要将此工厂当作抽象的 IFactory 接口使用即可。这种经过抽象的工厂方法模式被称作抽象工厂模式。
由于客户端只和 IFactory 打交道了,调用的是接口中的方法,使用时根本不需要知道是在哪个具体工厂中实现的这些方法,这就使得替换工厂变得非常容易。举个栗子:
public class User {
private void eat() {
IFactory factory = new AppleFactory();
Fruit fruit = factory.create();
fruit.eat();
}
}
如果要替换,只需要修改一行,修改对应的工厂即可:
public class User {
private void eat() {
IFactory factory = new PearFactory();
Fruit fruit = factory.create();
fruit.eat();
}
}
IFactory 中只有一个抽象方法时,或许还看不出抽象工厂模式的作用。实际上抽象工厂模式主要用于替换一系列方法。
抽象工厂模式很好的发挥了开闭原则、依赖倒置原则,但缺点是抽象工厂模式太重了,如果 IFactory 接口需要新增功能,则会影响到所有的具体工厂类。使用抽象工厂模式,替换具体工厂时只需更改一行代码,但要新增抽象方法则需要修改所有的具体工厂类。所以抽象工厂模式适用于增加同类工厂这样的横向扩展需求,不适合新增功能这样的纵向扩展。