23种设计模式学习之东拼西凑-------抽象工厂模式

我的理解就是给与最大的方便添加新的工厂。按照下面的内容进行抽象工厂模式分解创建。

抽象工厂（Abstract Factory)
声明生成一系列抽象产品的方法

具体工厂（Concrete Factory）
执行生成一系列抽象产品的方法，生成一系列具体的产品

抽象产品（Abstract Product）
为这一系列的某一种产品声明接口

具体产品（Product）
定义具体工厂生成的具体产品的对象，实现产品接口

客户（Client）
我们的应用程序客户端（不要理解成人），使用抽象产品和抽象工厂生成对象。

用网上搜到的代码案例进行学习理解：

中国企业需要一项简单的财务计算：每月月底，财务人员要计算员工的工资。
员工的工资 = (基本工资 + 奖金 - 个人所得税)。这是一个放之四海皆准的运算法则。
为了简化系统，我们假设员工基本工资总是4000美金。
中国企业奖金和个人所得税的计算规则是:
奖金 = 基本工资(4000) * 10%
个人所得税 = (基本工资 + 奖金) * 40%
我们现在要为此构建一个软件系统（代号叫Softo），满足中国企业的需求。
建立抽象工厂：

这个是常量

namespace AbstractFactory
{
/// <summary>
/// 公用的常量
/// </summary>
public class Constant
{
public static double BASE_SALARY = 4000;

}
}

抽象工厂：

namespace AbstractFactory
{
/// <summary>
/// Factory类
/// </summary>

public abstract class AbstractFactory
{
public static AbstractFactory GetInstance()
{
string factoryName = Constant.STR_FACTORYNAME.ToString();

AbstractFactory instance;

if(factoryName == "ChineseFactory")
instance = new ChineseFactory();
else if(factoryName == "AmericanFactory")
instance = new AmericanFactory();
else
instance = null;

return instance;
}

public abstract Tax CreateTax();

public abstract Bonus CreateBonus();
}
}

抽象产品（Abstract Product）

/// <summary>
/// 奖金抽象类
/// </summary>
public abstract class Bonus
{
public abstract double Calculate();
}

抽象产品（Abstract Product）

/// <summary>
/// 个人所得税抽象类
/// </summary>
public abstract class Tax
{
public abstract double Calculate();
}
}

配置文件：

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
<appSettings>
<add key="factoryName" value="AmericanFactory"></add>
</appSettings>
</configuration>

具体工厂：

1

namespace AbstractFactory
{
/// <summary>
/// ChineseFactory类
/// </summary>
public class ChineseFactory:AbstractFactory
{
public override Tax CreateTax()
{
return new ChineseTax();
}

public override Bonus CreateBonus()
{
return new ChineseBonus();
}
}
}

具体产品（Product）

/// <summary>
/// 计算中国个人奖金
/// </summary>
public class ChineseBonus:Bonus
{
public override double Calculate()
{
return Constant.BASE_SALARY * 0.1;
}
}

具体产品（Product）

/// <summary>
/// 计算中国个人所得税
/// </summary>
public class ChineseTax:Tax
{
public override double Calculate()
{
return (Constant.BASE_SALARY + (Constant.BASE_SALARY * 0.1)) * 0.5;
}
}

2.

namespace AbstractFactory
{
/// <summary>
/// AmericanFactory类
/// </summary>
public class AmericanFactory:AbstractFactory
{
public override Tax CreateTax()
{
return new AmericanTax();
}

public override Bonus CreateBonus()
{
return new AmericanBonus();
}
}
}

具体产品（Product）

/// <summary>
/// 计算美国个人所得税
/// </summary>
public class AmericanTax:Tax
{
public override double Calculate()
{
return (Constant.BASE_SALARY + (Constant.BASE_SALARY * 0.1)) * 0.4;
}
}

具体产品（Product）

/// <summary>
/// 计算美国奖金
/// </summary>
public class AmericanBonus:Bonus
{
public override double Calculate()
{
return Constant.BASE_SALARY * 0.1;
}
}

剩下的就是客户端了：

/// <summary>
/// 客户端程序调用
/// </summary>
public class Calculator
{
public static void Main(string[] args)
{
AmericanBonus bonus = new AmericanBonus();
double bonusValue = bonus.Calculate();

AmericanTax tax = new AmericanTax();
double taxValue = tax.Calculate();

double salary = 4000 + bonusValue - taxValue;

Console.WriteLine("American Salary is：" + salary);
Console.ReadLine();
}
}

这样就完成了抽象类的模式，似乎没什么优点。除了可以通过配文件控制产品之外。假若现在增加新的具体工厂类，发现还是需要修改抽象类。不过可以通过反射解决。

现在修改抽象类为反射机制：

/// <summary>
/// Factory类
/// </summary>
public abstract class AbstractFactory
{

public static AbstractFactory GetInstance()
{
string factoryName = Constant.STR_FACTORYNAME.ToString();

AbstractFactory instance;

if(factoryName != "")
instance = (AbstractFactory)Assembly.Load("AbstractFactory").CreateInstance("AbstractFactory." + factoryName);
else
instance = null;

return instance;
}

public abstract Tax CreateTax();

public abstract Bonus CreateBonus();
}

抽象产品与具体工厂等同上。

现在修改客户端：

/// <summary>
/// 客户端程序调用
/// </summary>
public class Calculator
{
public static void Main(string[] args)
{
AbstractFactory sds = AbstractFactory.GetInstance();
Bonus bonus = sds.CreateBonus();
double bonusValue = bonus.Calculate();

Tax tax = sds.CreateTax();
double taxValue = tax.Calculate();

double salary = 4000 + bonusValue - taxValue;

Console.WriteLine("Salary is：" + salary);
Console.ReadLine();
}
}

这样我们发现即使再增加新的系列产品，只需要继承抽象工厂实现具体工厂代码就可以了！

总结：

抽象工厂模式提供了一个创建一系列相关或相互依赖对象的接口，运用抽象工厂模式的关键点在于应对“多系列对象创建”的需求变化