工厂方法模式

关注

原创最新推荐文章于 2026-02-23 00:08:58 发布 113 阅读 AI 写同款· GEO 优化 ›

概述

工厂方法模式，英文Factory method pattern，工厂方法模式是简单工厂模式的进化版，看本文之间最好先看一下简单工厂模式。工厂方法模式是定义一个创建产品对象的工厂接口，工厂接口本身不去创建对象，而是交给其子类或者是其实现类去创建，将实际创建工作推迟到子类中进行，我们先看一下如何实现工厂方法模式，最后再说一下它有什么好处。

实现

Operation.java，运算基类，抽象getResult方法。

public abstract class Operation {

protected double numA;

protected double numB;

public double getNumA() {

return numA;

}

public void setNumA(double numA) {

this.numA = numA;

}

public double getNumB() {

return numB;

}

public void setNumB(double numB) {

this.numB = numB;

}

public abstract double getResult();

}

AddOperation.java，加法运算类，继承自Operation，实现getResult方法。

/* 加法 */

public class AddOperation extends Operation {

@Override

public double getResult() {

return numA + numB;

}

SubOperation.java，减法运算类，继承自Operation，实现getResult方法。

/* 减法 */

public class SubOperation extends Operation {

@Override

public double getResult() {

return numA - numB;

}

乘法、除法运算类略，可以见简单工厂模式第四章第三节。

IFactory.java，创建运算类的工厂接口，包含一个创建运算类的抽象方法。

public interface IFactory {

Operation createOperation();

}

AddFactory.java，加法工厂，实现IFactory，创建加法运算类。

public class AddFactory implements IFactory {

public Operation createOperation() {

return new AddOperation();

}

SubFactory.java，减法工厂，实现IFactory，创建减法运算类。

public class SubFactory implements IFactory {

public Operation createOperation() {

return new SubOperation();

}

乘法、除法工厂类略。

FactoryMethodTest.java，客户端类。

public class FactoryMethodTest {

public static void main(String[] args) {

IFactory factory = new AddFactory();

Operation operation = factory.createOperation();

operation.setNumA(1);

operation.setNumB(2);

System.out.println(operation.getResult());

}

UML

从UML类图中可以看出，工厂方法模式中工厂的个数是和运算类的个数是一样的，也就是说增加一个运算类，就需要增加一个工厂。而简单工厂方法模式中增加一个运算类，需要在静态工厂方法中增加一个判断分支，这样看起来好像工厂方法模式反而麻烦了。现在就得引入软件设计中的一个原则，开放-封闭原则。

原则

软件设计中，有很多设计原则，可能我们并非一定要遵守，但我们一定要尽量遵守，因为这始终是利大于弊的。

开放-封闭原则

针对扩展是开放的，针对修改是封闭的。详细介绍可以见百度百科，开放-封闭原则是面向对象设计的核心所在，遵循这个原则可以带来巨大好处，可扩展、可维护、可复用。再来说简单工厂方法模式，我需要增加一种运算时，需要增加一个新的运算类，这没有错，但是还需要修改工厂方法，增加分支，这就违背了开放-封闭原则，工厂方法模式就是基于其上的遵循开放-封闭原则的解决方案，针对工厂的变化，抽象出来工厂接口，将静态工厂中的每个分支判断都抽成单独的工厂类，这也是前文提到过的将if…else分支判断转成单独的类，是代码结构更清晰。

里氏代换原则

Liskov Substitution Principle，简称LSP。子类型必须能替换掉他们的父类型。换句话说，在软件里面，把使用父类的地方，都换成子类，程序的行为是没有变化的。这是面向对象语言继承的基础，如果没有里氏代换原则，也就谈不上开放-关闭原则了，比如：

动物 animal = new 动物();

animal.吃();

animal.喝();

animal.叫();

根据里氏代换原则，将动物对象换成狗、牛、骆驼，其它地方不变，是完全可以执行的。

依赖倒置原则

也叫依赖倒转原则，Dependence Inversion Principle，对抽象进行编程，不要对实现进行编程。面相对象设计将就高内聚、低耦合，高内聚指功能相关性很强的紧密的结合在一起，遵守单一职责原则；耦合是指不同模块或不同层次代码的联系程度，耦合性越低，模块独立性越强，耦合性越高，模块独立性越弱，高耦合的软件，往往修改一处地方，都会牵一发而动全身，这就是设计不当。举个硬件的例子，内存条和主板是通过金手指和主板内存槽连接的，主板定义好插内存条的接口，各个内存条厂商都根据这个标准接口去制作自己的内存条，假如内存条坏了，不能开机了，我不需要去换主板，到中关村买个新的内存条插上即可(话说显卡什么时候能这样做啊，所谓的“独显”都不是真正的独显)。