编程语言
首页 > 编程语言> > Java设计模式-简单工厂模式

Java设计模式-简单工厂模式

作者:互联网

一、简单工厂模式的概述

1. 定义:定义一个工厂类,它可以根据不同的参数返回不同的实例,被创建的实例通常具有相同的父类

以活字印刷术为例,不同活字的排列组合得到不同的文章,这些文章的活字都来源于同一套活字模板

2. 在简单工厂中被创建的实例方法通常是静态方法(Static Method),因此简单工厂模式又被成为静态工厂方法(Statis Factory Method) 

 

二、简单工厂模式的结构和实现

1. 结构

1)Factory(工厂):核心部分,负责实现创建所有产品的内部逻辑,工厂类可以被外界直接调用,创建所需对象

2)Product(抽象类产品):工厂类所创建的所有对象的父类,封装了产品对象的公共方法,所有的具体产品为其子类对象

3)ConcreteProduct(具体产品):简单工厂模式的创建目标,所有被创建的对象都是某个具体类的实例。它要实现抽象产品中声明的抽象方法(有关抽象类)

 

2. 实现

/**
 * @author ***
 * @title: Test2
 * @projectName design-pattern
 * @description TODO
 * @date 2021/7/510:27
 */
abstract class Product {
    public static void MethName() {
        //公共方法的实现
    }

    public abstract void MethodDiff();
    //声明抽象业务方法
}

class ConcreteProductA extends Product {
    @Override
    public void MethodDiff() {
        //业务方法的实现
    }
}

class ConcreteProductB extends Product {
    @Override
    public void MethodDiff() {
        //业务方法的实现
    }
}

class Factory {
    public static Product GetProduct(String arg) {
        Product product = null;
        if (arg.equals("A")){
            product = new ConcreteProductA();
            //init
        }else if (arg.equals("B")) {
            product = new ConcreteProductB();
            //init
        } else {
            //其他情况
        }
        return product;
    }
}

class Program {
    public static void main(String[] args) {
        Product product;
        product = Factory.GetProduct("A");//工厂类创建对象
        Product.MethName();
        product.MethodDiff(); 
    }
       
}

 

三、简单工厂模式的优缺点和适用环境  

1. 优点

1)工厂类包含必要的逻辑判断,可以决定在什么时候创建哪一个产品的实例。客户端可以免除直接创建产品对象的职责
2)客户端无需知道所创建具体产品的类名,只需知道参数即可
3)也可以引入配置文件,在不修改客户端代码的情况下更换和添加新的具体产品类。(这也是我在开始的披萨店里遇到没有的披萨的解决情况)

2. 缺点

1)工厂类集中了所有产品的创建逻辑,职责过重,一旦异常,整个系统将受影响
2)使用简单工厂模式会增加系统中类的个数(引入新的工厂类),增加系统的复杂度和理解难度
3)系统扩展困难,一旦增加新产品不得不修改工厂逻辑,在产品类型较多时,可能造成逻辑过于复杂
4)简单工厂模式使用了static工厂方法,造成工厂角色无法形成基于继承的等级结构。

3. 适用环境

1)工厂类负责创建对的对象比较少,因为不会造成工厂方法中的业务逻辑过于复杂

2)客户端只知道传入工厂类的参数,对如何创建对象不关心

 

四、实际案例

利用简单工厂模式编写一款简单的计算器软件程序

我们在设计的时候最重要是将界面逻辑(main方法)和业务逻辑(普通方法)分开,降低代码之间的耦合度

业务逻辑:

/**
 * @author ***
 * @title: Operation
 * @projectName design-pattern
 * @description 运算抽象类
 * @date 2021/7/510:49
 */
public abstract class Operation {
    private double _numberA = 0;
    private double _numberB = 0;

    public double get_numberA() {
        return _numberA;
    }
    public void set_numberA(double _numberA) {
        this._numberA = _numberA;
    }
    public double get_numberB() {
        return _numberB;
    }
    public void set_numberB(double _numberB) {
        this._numberB = _numberB;
    }

    public abstract double getResult();
}
/**
 * @author ***
 * @title: OperationAdd
 * @projectName design-pattern
 * @description 加法类,继承运算类
 * @date 2021/7/5 10:50
 */
public class OperationAdd extends Operation{
    @Override
    public double getResult() {
        double result = 0;
        return get_numberA() + get_numberB();
    }
}
/**
 * @author ***
 * @title: OperationSub
 * @projectName design-pattern
 * @description 加减乘除类 -- 减法类,继承运算类
 * @date 2021/7/5 10:51
 */
public class OperationSub extends Operation{
    @Override
    public double getResult() {
        double result = 0;
        return get_numberA() - get_numberB();
    }
}
/**
 * @author ***
 * @title: OperationMul
 * @projectName design-pattern
 * @description 加减乘除类 -- 乘法类,继承运算类
 * @date 2021/7/5 10:53
 */
public class OperationMul extends Operation{
    @Override
    public double getResult() {
        double result = 0;
        return get_numberA() * get_numberB();
    }
}
/**
 * @author ***
 * @title: OperationDiv
 * @projectName design-pattern
 * @description 加减乘除类 -- 除法类,继承运算类
 * @date 2021/7/5 10:54
 */
public class OperationDiv extends Operation{
    @Override
    public double getResult() {
        double result = 0;
        return get_numberA() / get_numberB();
    }
}
/**
 * @author ***
 * @title: OperationFacotry
 * @projectName design-pattern
 * @description 简单运算工厂类
 * @date 2021/7/5 10:57
 */
public class OperationFactory {
    public static Operation createOperate(String operate){
        Operation oper = null;
        switch (operate)
        {
            case "+":
                oper = new OperationAdd();
                break;
            case "-":
                oper = new OperationSub();
                break;
            case "*":
                oper = new OperationMul();
                break;
            case "/":
                oper = new OperationDiv();
                break;
        }
        return oper;
    }
}

界面逻辑:

/**
 * @author ***
 * @title: ClassC
 * @projectName design-pattern
 * @description 客户端代码
 * @date 2021/7/5 10:58
 */
public class ClassC {
    public static void main(String[] args) {
        Operation oper;
        oper = OperationFactory.createOperate("-");
        oper.set_numberA(1);
        oper.set_numberB(2);
        double result = oper.getResult();
        System.out.println("结果是:" + result);
    }
}

如此一来,那么我们需要增加各种复杂运算,比如平方根,立方根,自然对数,正弦余弦等,只需增加相应的运算子类就可以了。 

 

标签:Java,numberA,double,class,工厂,numberB,设计模式,public
来源: https://www.cnblogs.com/mylqm/p/14971284.html