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

来实现吧，简易计算器

代码能否复用性

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

多态，简化代码大杀器

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

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 抽象工厂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;
//}
}
}
}

对抽象工厂的总结：

总结