欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

设计模式 | 工厂方法模式(factory method)

程序员文章站 2022-03-21 20:39:38
定义: 定义: 定义一个用于创建对象的接口,让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。 结构:(书中图,侵删) 一个工厂的抽象接口 若干个具体的工厂类 一个需要创建对象的抽象接口 若干个所需创建的对象的类 较之简单工厂方法,多了一层抽象——将工厂也抽象了;由原来的一个万能工厂变 ......

定义:

定义一个用于创建对象的接口,让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。

结构:(书中图,侵删)

设计模式 | 工厂方法模式(factory method)

一个工厂的抽象接口
若干个具体的工厂类
一个需要创建对象的抽象接口
若干个所需创建的对象的类
 
较之简单工厂方法,多了一层抽象——将工厂也抽象了;由原来的一个万能工厂变为现在的若干个各司其职的工厂。
设计模式 | 工厂方法模式(factory method)
 
设计模式 | 工厂方法模式(factory method)
导致的结果就是:原本新增一个要创建的对象需要直接修改万能工厂类,增加判断,违反了开放-封闭原则;
现在工厂相关代码不用改,只需要新增工厂类即可,同时将判断转移给了客户端。
 
既然是和简单工厂相对比,就还是延用之前计算器的例子:(同样,为了代码简洁不考虑输入不合法等代码健壮性)
抽象工厂接口:
package designpattern.factorymethod;

import designpattern.staticfactorymethod.calculate;

public interface calculatefactory {
    calculate create();
}
若干工厂接口:
package designpattern.factorymethod;

import designpattern.staticfactorymethod.calculate;
import designpattern.staticfactorymethod.plus;

public class plusfactory implements calculatefactory{

    @override
    public calculate create() {
        return new plus();
    }

}
package designpattern.factorymethod;

import designpattern.staticfactorymethod.calculate;
import designpattern.staticfactorymethod.minus;

public class minusfactory implements calculatefactory {

    @override
    public calculate create() {
        return new minus();
    }

}

package designpattern.factorymethod;

import designpattern.staticfactorymethod.calculate;
import designpattern.staticfactorymethod.multiply;

public class multiplyfactory implements calculatefactory {

    @override
    public calculate create() {
        return new multiply();
    }

}
package designpattern.factorymethod;

import designpattern.staticfactorymethod.calculate;
import designpattern.staticfactorymethod.divide;

public class dividefactory implements calculatefactory {

    @override
    public calculate create() {
        return new divide();
    }

}

抽象计算类及若干具体计算类:(延用之前简单工厂方法的代码)
抽象类:
package designpattern.staticfactorymethod;

public abstract class calculate {
    public double num1;
    public double num2;

    calculate() {
    }

    calculate(double num1, double num2) {
        this.num1 = num1;
        this.num2 = num2;
    }

    public abstract double calculate();
}

加:

package designpattern.staticfactorymethod;

public class plus extends calculate {
    public plus() {
    }

    plus(double num1, double num2) {
        super(num1, num2);
    }

    @override
    public double calculate() {
        return num1 + num2;
    }

}
package designpattern.staticfactorymethod;

public class minus extends calculate {
    public minus() {
    }

    minus(double num1, double num2) {
        super(num1, num2);
    }

    @override
    public double calculate() {
        return num1 - num2;
    }

}
package designpattern.staticfactorymethod;

public class multiply extends calculate {
    public multiply() {
    }

    multiply(double num1, double num2) {
        super(num1, num2);
    }

    @override
    public double calculate() {
        return num1 * num2;
    }

}
package designpattern.staticfactorymethod;

public class divide extends calculate {
    public divide() {
    }

    divide(double num1, double num2) {
        super(num1, num2);
    }

    @override
    public double calculate() {
        return num1 / num2;
    }

}
客户端:
package designpattern.factorymethod;

import java.util.scanner;

import designpattern.staticfactorymethod.calculate;

public class client {
    public static void main(string[] args) {
        scanner scanner = new scanner(system.in);
        system.out.println("请输入一个数字");
        double num1 = scanner.nextdouble();
        system.out.println("请输入一个运算符:+、-、*、/");
        string operator = scanner.next();// 不能用nextline(),会把上一个回车给吸收
        system.out.println("请输入一个数字");
        double num2 = scanner.nextdouble();
        calculatefactory calculatefactory = null;

        switch (operator) {
        case "+":
            calculatefactory = new plusfactory();
            break;
        case "-":
            calculatefactory = new minusfactory();
            break;
        case "*":
            calculatefactory = new multiplyfactory();
            break;
        case "/":
            calculatefactory = new dividefactory();
            break;
        default:
            break;
        }
        calculate calculate = calculatefactory.create();
        calculate.num1 = num1;
        calculate.num2 = num2;
        system.out.println(calculate.calculate());
        scanner.close();
    }
}

总结:

工厂方法模式就是在简单工厂方法模式的基础上进一步抽象,使其符合开放-封闭原则。
个人理解,在轻量级系统,或者工厂所能创建的东西较少可能修改的情况下,可以考虑使用简单工厂模式;
否则,需要使用工厂方法模式。