设计模式(C#)——02简单工厂模式

时间:2023-03-08 20:13:52

推荐阅读:

      工厂模式主要是为创建对象提供过渡接口,以便将创建对象的具体过程屏蔽隔离起来。通俗来说,你只关心怎么用,不用关心怎么做。

工厂模式可以分为三类:

1.简单工厂模式(Simple Factory)

2.工厂方法模式(Factory Method)

3.抽象工厂模式(Abstract Factory)

      掌握简单工厂模式是我们学习工厂模式最基础的条件,只有理解了简单的,才能更深入的学习。对于刚接触设计模式的朋友来说,看前一篇单例模式的朋友觉得挺轻松,但今天要将的工厂模式可能就不是特别容易消化了。为了让大家更深刻的理解这个模式,我将给大家展现出一个有趣的学习过程。

简单工厂模式(Simple Factory Pattern)

简单工厂模式又称静态工厂方法模式(Static Factory Method)。

简单工厂模式要素:

①抽象基类:类中定义抽象一些方法,用以在子类中实现,通俗的说就是抽象产品。例:运算类my_opterator

②继承自抽象基类的子类:实现基类中的抽象方法,通俗的说就是具体的产品。例:加法类ADDopterator,乘法类MULopertator等

③工厂类:用以实例化对象。例如:factory

下面举个例子用类图来介绍一下上面几个要素之间的关系吧。

实现算术运算:

设计模式(C#)——02简单工厂模式

      命名空间简单工厂模式中包含抽象运算基类my_opterator、四个具体运算类、工厂类factory。本案例将向大家展示如何使用简单工厂模式来进行不同的算术运算。

代码实现过程:

1.创建抽象类my_opterator

abstract class my_opterator                 //算法类父类
{
private double m_a, m_b;
public double A //A属性
{
get { return m_a; }
set { m_a = value; }
}
public double B //B属性
{
get { return m_b; }
set { m_b = value; }
}
abstract public double getresult(); //抽象方法,获得结果
}

2.创建继承抽象类的子类。

class ADDopterator : my_opterator           //加法类
{
public override double getresult() //抽象方法的实现
{
return A + B;
}
} class SUBoperator : my_opterator //减法类
{
public override double getresult() //抽象方法的实现
{
return A - B;
}
} class MULopertator : my_opterator //乘法类
{
public override double getresult() //抽象方法的实现
{
return A * B;
}
} class DIVoperator : my_opterator //除法类
{
public override double getresult() //抽象方法的实现
{
return A / B;
}
}

3.创建一个工厂,生成基于给定信息的实体类的对象

class factory                                       //简单工厂类
{
private my_opterator m_opt;
public my_opterator createclass(string opt, double a, double b)
{
switch(opt)
{
case "+":
{
m_opt = new ADDopterator();
break;
}
case "-":
{
m_opt = new SUBoperator();
break;
}
case "*":
{
m_opt = new MULopertator();
break;
}
case "/":
{
m_opt = new DIVoperator();
break;
}
}
m_opt.A = a;
m_opt.B = b;
return m_opt;
}
}

4.使用该工厂,通过传递类型信息来获取实体类的对象。


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text; namespace 简单工厂模式
{
class Program
{
static void Main(string[] args)
{
string A, B;
string opt;
Console.WriteLine("请输入数字A:");
A = Console.ReadLine();
Console.WriteLine("请输入运算符:");
opt = Console.ReadLine();
Console.WriteLine("请输入数字B:");
B = Console.ReadLine(); my_opterator my_opt; //算法类父类
factory fa = new factory(); //简单工厂类
my_opt = fa.createclass(opt, Convert.ToDouble(A), Convert.ToDouble(B)); //调用生产算法方法
Console.WriteLine(my_opt.getresult());
}
}
}

      从上面代码可以发现:系统难以扩展,一旦添加新产品就不得不修改简单工厂方法,这样就会造成简单工厂的实现逻辑过于复杂。

整合后的代码:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text; namespace 简单工厂模式
{
class Program
{
static void Main(string[] args)
{
string A, B;
string opt;
Console.WriteLine("请输入数字A:");
A = Console.ReadLine();
Console.WriteLine("请输入运算符:");
opt = Console.ReadLine();
Console.WriteLine("请输入数字B:");
B = Console.ReadLine(); my_opterator my_opt; //算法类父类
factory fa = new factory(); //简单工厂类
my_opt = fa.createclass(opt, Convert.ToDouble(A), Convert.ToDouble(B)); //调用生产算法方法
Console.WriteLine(my_opt.getresult());
}
}
} class factory //简单工厂类
{
private my_opterator m_opt;
public my_opterator createclass(string opt, double a, double b)
{
switch(opt)
{
case "+":
{
m_opt = new ADDopterator();
break;
}
case "-":
{
m_opt = new SUBoperator();
break;
}
case "*":
{
m_opt = new MULopertator();
break;
}
case "/":
{
m_opt = new DIVoperator();
break;
}
}
m_opt.A = a;
m_opt.B = b;
return m_opt;
}
} abstract class my_opterator //算法类父类
{
private double m_a, m_b;
public double A //A属性
{
get { return m_a; }
set { m_a = value; }
}
public double B //B属性
{
get { return m_b; }
set { m_b = value; }
}
abstract public double getresult(); //抽象方法,获得结果
} class ADDopterator : my_opterator //加法类
{
public override double getresult() //抽象方法的实现
{
return A + B;
}
} class SUBoperator : my_opterator //减法类
{
public override double getresult() //抽象方法的实现
{
return A - B;
}
} class MULopertator : my_opterator //乘法类
{
public override double getresult() //抽象方法的实现
{
return A * B;
}
} class DIVoperator : my_opterator //除法类
{
public override double getresult() //抽象方法的实现
{
return A / B;
}
}