Thinking In Design Pattern——工厂模式演绎

来实现吧，简易计算器

namespace 工厂模式之简单计算器
{
/// <summary>
/// 版本一
/// </summary>
class Program
{
//很差劲,统一交给了Main函数,没有重用的地方,不能体现重用性
//这是面向过程编程
//客户端耦合性很高,想扩展其余运算靠修改Swith语句
//总之就是一坨代码

static void Main(string[] args)
{
Console.WriteLine("请输入一个数：a=");
int a = Convert.ToInt32(Console.ReadLine());

Console.WriteLine("请输入另一个数:b=");
int b = Convert.ToInt32(Console.ReadLine());

Console.WriteLine("请输入操作运算符");
string op = Console.ReadLine();
int result = 0;

switch (op)
{
case "+":
result = a + b;
break;
case "-":
result = a - b;
break;
case "*":
result=a*b;
break;
case "/":
result = a / b;
break;
default:
break;
}
Console.WriteLine("{0}{1}{2}={3}",a,op,b,result);
Console.ReadKey();
}
}
}

代码能否复用性

namespace 工厂模式Demo2
{
/// <summary>
/// 版本二：考虑方法的重用性,注意这儿依旧是面向过程运算,不是面向对象
/// </summary>
class Program
{
static void Main(string[] args)
{
Console.WriteLine("请输入一个数：a=");
int a = Convert.ToInt32(Console.ReadLine());

Console.WriteLine("请输入另一个数:b=");
int b = Convert.ToInt32(Console.ReadLine());

Console.WriteLine("请输入操作运算符");
string op = Console.ReadLine();
//这儿对第一版本进行修改,体现了方法的重用性
int result = Calculate(a, b, op);
Console.WriteLine("{0}{1}{2}={3}", a, op, b, result);
Console.ReadKey();
}

private static int Calculate(int a, int b, string op)
{
int result = 0;

switch (op)
{
case "+":
result = a + b;
break;
case "-":
result = a - b;
break;
case "*":
result = a * b;
break;
case "/":
result = a / b;
break;
default:
break;
}
return result;
}
}
}

忘记面向过程吧，面向对象思想的引入

namespace 工厂模式Demo3
{
/// <summary>
/// 增加一个Calculator计算父类
/// </summary>
class Program
{
static void Main(string[] args)
{
Console.WriteLine("请输入一个数A=");
int a = int.Parse(Console.ReadLine());
Console.WriteLine("请输入另一个数B=");
int b = int.Parse(Console.ReadLine());
Console.WriteLine("请输入运算符：");
string op = Console.ReadLine();
int result = 0;
//重复代码过多
switch (op)
{
case "+":
AddCalculate calcAdd = new AddCalculate();
calcAdd.NumberA = a;
calcAdd.NumberB = b;
result = calcAdd.GetResult;
break;
case "-":
SubCalculate calcSub = new SubCalculate();
calcSub.NumberA = a;
calcSub.NumberB = b;
result = calcSub.GetResult;
break;
case "*":
MultiCalculate calcMulti = new MultiCalculate();
calcMulti.NumberA = a;
calcMulti.NumberB = b;
result = calcMulti.GetResult;
break;
case "/":
DivisCalculate calcDiv = new DivisCalculate();
calcDiv.NumberA = a;
calcDiv.NumberB = b;
result = calcDiv.GetResult;
break;

default:
break;
}
Console.WriteLine("{0}{1}{2}={3}",a,op,b,result);
Console.ReadLine();
}
}
abstract class Calculate
{
protected int numberA;
//属性:封装字段
public int NumberA
{
get { return numberA; }
set { numberA = value; }
}
protected int numberB;
//属性：封装字段
public int NumberB
{
get { return numberB; }
set { numberB = value; }
}
/// <summary>
/// 抽象属性：由子类对象来完成计算
/// </summary>
public abstract int GetResult { get; }

}
/// <summary>
/// 加法运算类
/// </summary>
class AddCalculate : Calculate
{
public override int GetResult
{
get {return base.numberA + base.numberB;  }
}
}
/// <summary>
/// 减法运算类
/// </summary>
class SubCalculate : Calculate
{public override int GetResult
{
get { return base.numberA - base.numberB; }
}
}
/// <summary>
/// 乘法运算类
/// </summary>
class MultiCalculate : Calculate
{
public override int GetResult
{
get { return base.numberA * base.numberB; }
}
}
/// <summary>
/// 除法运算类
/// </summary>
class DivisCalculate : Calculate
{
public override int GetResult
{
get { return base.numberA / base.numberB; }
}
}
}

多态，简化代码大杀器

namespace 工厂模式Demo4
{
/// <summary>
/// 这个版本较上个版本也是质的飞跃,引入了多态这个概念。
/// 但是发现客户端耦合度还是高,除了要认识父类外,还要认识加减乘除类
/// 所以尽量来解耦,就像我去商店买笔,没必要知道笔是怎么制造的
/// 也就是说客户端只要和父类耦合即可,子类没必要和客户端耦合
/// </summary>
class Program
{
static void Main(string[] args)
{
Console.WriteLine("请输入一个数A=");
int a = int.Parse(Console.ReadLine());
Console.WriteLine("请输入另一个数B=");
int b = int.Parse(Console.ReadLine());
Console.WriteLine("请输入运算符：");
string op = Console.ReadLine();
int result = 0;
//对上一版本进行修改,定义了父类
Calculate calc = null;

switch (op)
{
case "+":
calc = new AddCalculate();//多态
break;
case "-":
calc = new SubCalculate();
break;
case "*":
calc = new MultiCalculate();
break;
case "/":
calc = new DivisCalculate();
break;

default:
break;
}
calc.NumberA = a;
calc.NumberB = b;
result=calc.GetResult;
Console.WriteLine("{0}{1}{2}={3}", a, op, b, result);
Console.ReadLine();
}
}
abstract class Calculate
{
protected int numberA;
//属性:封装字段
public int NumberA
{
get { return numberA; }
set { numberA = value; }
}
protected int numberB;
//属性：封装字段
public int NumberB
{
get { return numberB; }
set { numberB = value; }
}
/// <summary>
/// 抽象属性：由子类对象来完成计算
/// </summary>
public abstract int GetResult { get; }

}
/// <summary>
/// 加法运算类
/// </summary>
class AddCalculate : Calculate
{
public override int GetResult
{
get
{

return base.NumberA + base.NumberB;
}
}
}
/// <summary>
/// 减法运算类
/// </summary>
class SubCalculate : Calculate
{

public override int GetResult
{
get { return base.NumberA - base.numberB; }
}
}
/// <summary>
/// 乘法运算类
/// </summary>
class MultiCalculate : Calculate
{
public override int GetResult
{
get { return base.numberA * base.numberB; }
}
}
/// <summary>
/// 除法运算类
/// </summary>
class DivisCalculate : Calculate
{
public override int GetResult
{
get { return base.numberA / base.numberB; }
}
}
}

质的飞跃，简单工厂模式的运用

namespace 简单工厂模式 { /// <summary>
/// 简单工厂特点： /// 1.只有一个工厂(不是抽象) /// 2.只有一种类型的产品(基类,与子类数量无关) /// 3.一个工厂只生产一种类型产品 /// </summary>
class Program { static void Main(string[] args) { Console.WriteLine("请输入一个数A="); int a = int.Parse(Console.ReadLine()); Console.WriteLine("请输入另一个数B="); int b = int.Parse(Console.ReadLine()); Console.WriteLine("请输入运算符："); string op = Console.ReadLine(); int result = 0; Calculate calc=SimpleFactory.GetCalc(op);//解耦了,客户端不认识具体的类,用简单工厂类封装了这种复杂度,也就是去耦合度。这样客户端和工厂、抽象的产品耦合了。
calc.NumberA=a; calc.NumberB=b; result = calc.GetResult; Console.WriteLine("{0}{1}{2}={3}", a, op, b, result); Console.ReadLine(); } } /// <summary>
///创建一个简单工厂 /// </summary>
static class SimpleFactory { /// <summary>
/// 简单工厂封装了对象创建的复杂度 /// </summary>
/// <param name="op"></param>
/// <returns>产品的抽象</returns>
public static Calculate GetCalc(string op) { Calculate calc = null; switch (op) { case "+": calc = new AddCalculate();//多态
break; case "-": calc = new SubCalculate(); break; case "*": calc = new MultiCalculate(); break; case "/": calc = new DivisCalculate(); break; default: break; } return calc; } } abstract class Calculate { protected int numberA; //属性:封装字段
public int NumberA { get { return numberA; } set { numberA = value; } } protected int numberB; //属性：封装字段
public int NumberB { get { return numberB; } set { numberB = value; } } /// <summary>
/// 抽象属性：由子类对象来完成计算 /// </summary>
public abstract int GetResult { get; } } /// <summary>
/// 加法运算类 /// </summary>
class AddCalculate : Calculate { public override int GetResult { get { return base.NumberA + base.NumberB; } } } /// <summary>
/// 减法运算类 /// </summary>
class SubCalculate : Calculate { public override int GetResult { get { return base.NumberA - base.numberB; } } } /// <summary>
/// 乘法运算类 /// </summary>
class MultiCalculate : Calculate { public override int GetResult { get { return base.numberA * base.numberB; } } } /// <summary>
/// 除法运算类 /// </summary>
class DivisCalculate : Calculate { public override int GetResult { get { return base.numberA / base.numberB; } } } }

迷途知返，拨开云雾见工厂方法

namespace 工厂方法 { //Factory Method模式主要用于隔离类对象的使用者(Main函数)和具体类型（我在Main函数里只知道抽象的父类，也不知道具体的实现子类）之间的耦合关系(迪米特法则：用户知道越少越好,这样封装性越高)。面对一个经常变化的具体类型，紧耦合关系会导致软件的脆弱。
class Program { static void Main(string[] args) { Console.WriteLine("请输入A:"); int a = int.Parse(Console.ReadLine()); Console.WriteLine("请输入B:"); int b = int.Parse(Console.ReadLine()); Console.WriteLine("请输入运算符"); string op = Console.ReadLine(); 运算AbstractFactory factory = null; Calculate calc = null; #region 这儿就是局部化
//注意：这里的switch不是必须的,可以利用反射技术动态创建工厂的实例
//反射详见抽象工厂
switch (op) { case "+": factory = new 加法Factory(); break; case "-": factory = new 减法Factory(); break; case "*": factory = new 乘法Factory(); break; case "/": factory = new 除法Factory(); break; default: break; } #endregion calc = factory.GetCalc(); calc.NumberA = a; calc.NumberB = b; int result = calc.GetResult; Console.WriteLine(result); Console.ReadKey(); } } //1.Factory Method模式通过面向对象的手法，将所要创建的具体对象工作延迟到子类，从而实现一种扩展（而非更改）的策略（开放封闭原则思想），较好地解决了这种紧耦合关系。（和简单工厂比较） //2.工厂类和产品类往往可以依次对应,即一个抽象工厂对应一个抽象产品，一个具体工厂对应一个具体产品（体现了类的单一职责），这个具体的工厂就负责生产对应的产品。
abstract class 运算AbstractFactory { public abstract Calculate GetCalc(); } //通过继承来扩展，而非是修改Swith语句那样去修改————开放封闭原则,对扩展开放,对修改封闭
class 加法Factory : 运算AbstractFactory { public override Calculate GetCalc() { return new AddCalculate();//这里体现了推迟.../延迟到工厂子类 子类辅助帮助父类实现具体创建哪个对象，也就是New XXCalculate()
} } class 减法Factory : 运算AbstractFactory { public override Calculate GetCalc() { return new SubCalculate(); } } class 乘法Factory : 运算AbstractFactory { public override Calculate GetCalc() { return new MultiCalculate(); } } class 除法Factory : 运算AbstractFactory { public override Calculate GetCalc() { return new DivisCalculate(); } } ///////////////产品没变化//////////////

//对产品的抽象
abstract class Calculate { protected int numberA; //属性:封装字段
public int NumberA { get { return numberA; } set { numberA = value; } } protected int numberB; //属性：封装字段
public int NumberB { get { return numberB; } set { numberB = value; } } /// <summary>
/// 抽象属性：由子类对象来完成计算 /// </summary>
public abstract int GetResult { get; } } /// <summary>
/// 加法运算类 /// </summary>
class AddCalculate : Calculate { public override int GetResult { get { return base.NumberA + base.NumberB; } } } /// <summary>
/// 减法运算类 /// </summary>
class SubCalculate : Calculate { public override int GetResult { get { return base.NumberA - base.numberB; } } } /// <summary>
/// 乘法运算类 /// </summary>
class MultiCalculate : Calculate { public override int GetResult { get { return base.numberA * base.numberB; } } } /// <summary>
/// 除法运算类 /// </summary>
class DivisCalculate : Calculate { public override int GetResult { get { return base.numberA / base.numberB; } } } }

namespace 工厂方法3
{

class Program
{
static void Main(string[] args)
{
Console.WriteLine("请输入A:");
int a = int.Parse(Console.ReadLine());
Console.WriteLine("请输入B:");
int b = int.Parse(Console.ReadLine());
Console.WriteLine("请输入运算符");

string op = Console.ReadLine();

运算Factory factory = null;
Calculate calc = null;

#region 这儿就是局部化
//注意：这里的switch不是必须的,可以利用反射技术动态创建工厂的实例

switch (op)
{
case "+":
factory = new 加法Factory();

break;
case "-":
factory = new 减法Factory();
break;
case "*":
factory = new 乘法Factory();
break;
case "/":
factory = new 除法Factory();
break;
default:
break;
}
#endregion

calc = factory.GetCalc();
calc.NumberA = a;
calc.NumberB = b;
int result = calc.GetResult;
Console.WriteLine(result);
Console.ReadKey();

}
}

//注意：Creator不是抽象类了,而是一个具体的类
class 运算Factory
{

public virtual Calculate GetCalc()
{
return new AddCalculate();//默认缺省实现
}
}

//通过继承来扩展，而非是修改Swith语句那样去修改————开放封闭原则,对扩展开放,对修改封闭
class 加法Factory : 运算Factory
{

}
class 减法Factory : 运算Factory
{
public override Calculate GetCalc()
{
return new SubCalculate();
}
}
class 乘法Factory : 运算Factory
{
public override Calculate GetCalc()
{
return new MultiCalculate();
}
}
class 除法Factory : 运算Factory
{
public override Calculate GetCalc()
{
return new DivisCalculate();
}
}
///////////////产品没变化//////////////

//对产品的抽象
abstract class Calculate
{
protected int numberA;
//属性:封装字段
public int NumberA
{
get { return numberA; }
set { numberA = value; }
}
protected int numberB;
//属性：封装字段
public int NumberB
{
get { return numberB; }
set { numberB = value; }
}
/// <summary>
/// 抽象属性：由子类对象来完成计算
/// </summary>
public abstract int GetResult { get; }

}
/// <summary>
/// 加法运算类
/// </summary>
class AddCalculate : Calculate
{
public override int GetResult
{
get
{

return base.NumberA + base.NumberB;
}
}
}
/// <summary>
/// 减法运算类
/// </summary>
class SubCalculate : Calculate
{

public override int GetResult
{
get { return base.NumberA - base.numberB; }
}
}
/// <summary>
/// 乘法运算类
/// </summary>
class MultiCalculate : Calculate
{
public override int GetResult
{
get { return base.numberA * base.numberB; }
}
}
/// <summary>
/// 除法运算类
/// </summary>
class DivisCalculate : Calculate
{
public override int GetResult
{
get { return base.numberA / base.numberB; }
}
}

}

柳暗花明又一村：抽象工厂+工厂方法

namespace 抽象工厂Form { public partial class Form1 : Form { public Form1() { InitializeComponent(); } private Assembly assembly = null; private void button1_Click(object sender, EventArgs e) { OpenFileDialog dialog = new OpenFileDialog(); dialog.Filter = "exe文件|*.exe|dll文件|*.dll"; dialog.InitialDirectory = Application.StartupPath; if (dialog.ShowDialog()==DialogResult.OK) { //反射
assembly = System.Reflection.Assembly.LoadFile(dialog.FileName); this.comboBox1.Items.Clear(); foreach (var item in assembly.GetTypes()) { if (item.IsSubclassOf(typeof(SportShop))) { //将SportShop的两个子类加入下拉列表
this.comboBox1.Items.Add(item); } } } } private void button2_Click(object sender, EventArgs e) { Clothes clothes = null; Hat hat = null; SportShop shop = null; string typeName = ((Type)this.comboBox1.SelectedItem).FullName; //运行时刻创建一个具体工厂类的实例，这一具体工厂的创建具有特定实现的产品对象，为创建不同的产品对象，客户应使用不同的具体工厂(通过配置文件反射)
shop = Factory.CreateShop(assembly, typeName); clothes = shop.SellClothes(); hat = shop.SellHat(); MessageBox.Show(string.Format("衣服:{0},帽子:{1}", clothes, hat)); } } /// <summary>
/// 抽象的产品A /// </summary>
abstract class Clothes { } /// <summary>
/// 抽象的产品B /// </summary>
abstract class Hat { } /// <summary>
/// Nike产品A(系列1的产品A) /// </summary>
class NikeClothes : Clothes { public override string ToString() { return "Nike衣服"; } } /// <summary>
/// Nike产品B(系列1的产品B) /// </summary>
class NikeHat : Hat { public override string ToString() { return "Nike帽子"; } } /// <summary>
/// LiNing产品A(系列2的产品A) /// </summary>
class LiNingClothes : Clothes { public override string ToString() { return "LiNing衣服"; } } /// <summary>
/// LiNing产品B(系列2的产品B) /// </summary>
class LiNingHat : Hat { public override string ToString() { return "LiNing帽子"; } } /// <summary>
/// 抽象的工厂,负责规定创建产品(多种) /// </summary>
abstract class SportShop { /// <summary>
/// 创建产品A /// </summary>
/// <returns></returns>
public abstract Clothes SellClothes(); /// <summary>
/// 创建产品B /// </summary>
/// <returns></returns>
public abstract Hat SellHat(); } /// <summary>
/// 具体的系列1工厂 /// 把工厂作为单例，一个应用中一般每个产品系列只需一个具体工厂的实例，因此，工厂通常最好实现为一个单例模式。 /// </summary>
class NikeFactory : SportShop { //创建产品，抽象工厂仅声明一个创建产品的接口，真正创建产品是由具体工厂类创建的，最通常的一个办法是为每一个产品定义一个工厂方法，一个具体的工厂将为每个产品重定义该工厂方法以指定产品，虽然这样的实现很简单，但它要求每个产品系列都要有一个新的具体工厂子类，即使这些产品系列的差别很小。
public override Clothes SellClothes()//抽象工厂将产品对象的创建延迟到它的具体具体工厂子类中
{ return new NikeClothes(); } public override Hat SellHat() { return new NikeHat(); } } /// <summary>
/// 具体的系列2的工厂 /// </summary>
class LiNingFactory : SportShop { public override Clothes SellClothes() { return new LiNingClothes(); } public override Hat SellHat() { return new LiNingHat(); } } /// <summary>
/// Abstract Factory模式经常和Factory Method模式共同组合来应对“对象创建”的需求变化。 ///这里的处理很经典： 把SportShop可以看成是产品(之前还是系列),所以这儿是工厂方法 /// </summary>
static class Factory { public static SportShop CreateShop(Assembly assembly,string typeName) { //反射,当然Swith...Case也OK
return (SportShop)assembly.CreateInstance(typeName); //switch (typeName) //{ // case "Nike...": // return new NikeFactory(); // case "LiNing": // return new LiNingFactory(); // default: // break; //}
} } }

对抽象工厂的总结：

总结