# 抽象工厂模式（Abstract Factory）

442人阅读 评论(0)

奖金 = 基本工资(4000) * 10%

个人所得税 = (基本工资 + 奖金) * 40%

 1using System;
2
3namespace ChineseSalary
4{
5    /// <summary>
6    /// 公用的常量
7    /// </summary>
8    public class Constant
9    {
10        public static double BASE_SALARY = 4000;
11    }
12}

 1using System;
2
3namespace ChineseSalary
4{
5    /// <summary>
6    /// 计算中国个人奖金
7    /// </summary>
8    public class ChineseBonus
9    {
10        public double Calculate()
11        {
12            return Constant.BASE_SALARY * 0.1;
13        }
14    }
15}
16

1using System;
2
3namespace ChineseSalary
4{
5    /// <summary>
6    /// 计算中国个人所得税
7    /// </summary>
8    public class ChineseTax
9    {
10        public double Calculate()
11        {
12            return (Constant.BASE_SALARY + (Constant.BASE_SALARY * 0.1)) * 0.4;
13        }
14    }
15}
16

Chinese Salary is：2640

奖金 = 基本工资 * 15 %

个人所得税 = (基本工资 * 5% + 奖金 * 25%)

 1using System;
2
3namespace AmericanSalary
4{
5    /// <summary>
6    /// 公用的常量
7    /// </summary>
8    public class Constant
9    {
10        public static double BASE_SALARY = 4000;
11    }
12}
13

1using System;
2
3namespace AmericanSalary
4{
5    /// <summary>
6    /// 计算美国个人奖金
7    /// </summary>
8    public class AmericanBonus
9    {
10        public double Calculate()
11        {
12            return Constant.BASE_SALARY * 0.1;
13        }
14    }
15}
16

 1using System;
2
3namespace AmericanSalary
4{
5    /// <summary>
6    /// 计算美国个人所得税
7    /// </summary>
8    public class AmericanTax
9    {
10        public double Calculate()
11        {
12            return (Constant.BASE_SALARY + (Constant.BASE_SALARY * 0.1)) * 0.4;
13        }
14    }
15}
16

 1
2using System;
3
4namespace AmericanSalary
5{
6    /// <summary>
7    /// 客户端程序调用
8    /// </summary>
9    public class Calculator
10    {
11        public static void Main(string[] args)
12        {
13            AmericanBonus bonus = new AmericanBonus();
14            double bonusValue  = bonus.Calculate();
15
16            AmericanTax tax = new AmericanTax();
17            double taxValue = tax.Calculate();
18
19            double salary = 4000 + bonusValue - taxValue;
20
21            Console.WriteLine("American Salary is：" + salary);
23        }
24    }
25}
26

American Salary is：2640

1
2using System;
3
4namespace InterfaceSalary
5{
6    /// <summary>
7    /// 客户端程序调用
8    /// </summary>
9    public class Calculator
10    {
11        public static void Main(string[] args)
12        {
13            Bonus bonus = new ChineseBonus();
14            double bonusValue  = bonus.Calculate();
15
16            Tax tax = new ChineseTax();
17            double taxValue = tax.Calculate();
18
19            double salary = 4000 + bonusValue - taxValue;
20
21            Console.WriteLine("Chinaese Salary is：" + salary);
23        }
24    }
25}
26

1using System;
2
3namespace FactorySalary
4{
5    /// <summary>
6    /// Factory类
7    /// </summary>
8    public class Factory
9    {
10        public Tax CreateTax()
11        {
12            return new ChineseTax();
13        }
14
15        public Bonus CreateBonus()
16        {
17            return new ChineseBonus();
18        }
19    }
20}
21

1
2using System;
3
4namespace FactorySalary
5{
6    /// <summary>
7    /// 客户端程序调用
8    /// </summary>
9    public class Calculator
10    {
11        public static void Main(string[] args)
12        {
13            Bonus bonus = new Factory().CreateBonus();
14            double bonusValue  = bonus.Calculate();
15
16            Tax tax = new Factory().CreateTax();
17            double taxValue = tax.Calculate();
18
19            double salary = 4000 + bonusValue - taxValue;
20
21            Console.WriteLine("Chinaese Salary is：" + salary);
23        }
24    }
25}
26

 1using System;
2
3namespace FactorySalary
4{
5    /// <summary>
6    /// Factory类
7    /// </summary>
8    public class Factory
9    {
10        public Tax CreateTax()
11        {
12            return new AmericanTax();
13        }
14
15        public Bonus CreateBonus()
16        {
17            return new AmericanBonus();
18        }
19    }
20}
21

1using System;
2using System.Reflection;
3
4namespace AbstractFactory
5{
6     /// <summary>
7     /// AbstractFactory类
8     /// </summary>
9     public abstract class AbstractFactory
10    {
11        public static AbstractFactory GetInstance()
12        {
13            string factoryName = Constant.STR_FACTORYNAME.ToString();
14
15            AbstractFactory instance;
16
17            if(factoryName == "ChineseFactory")
18                instance = new ChineseFactory();
19            else if(factoryName == "AmericanFactory")
20                instance = new AmericanFactory();
21            else
22                instance = null;
23
24            return instance;
25        }
26
27        public abstract Tax CreateTax();
28
29        public abstract Bonus CreateBonus();
30    }
31}

1<?xml version="1.0" encoding="utf-8" ?>
2<configuration>
3    <appSettings>
5    </appSettings>
6</configuration>
7

1.      增加新的业务规则类JapaneseTax,JapaneseBonus分别实现Tax和Bonus接口。

2.      修改AbstractFactory的getInstance方法，增加else if(factoryName.equals("Japanese")){....

1using System;
2using System.Reflection;
3
4namespace AbstractFactory
5{
6    /// <summary>
7    /// AbstractFactory类
8    /// </summary>
9    public abstract class AbstractFactory
10    {
11        public static AbstractFactory GetInstance()
12        {
13            string factoryName = Constant.STR_FACTORYNAME.ToString();
14
15            AbstractFactory instance;
16
17            if(factoryName != "")
19            else
20                instance = null;
21
22            return instance;
23        }
24
25        public abstract Tax CreateTax();
26
27        public abstract Bonus CreateBonus();
28    }
29}
30

Softo系统的实际开发的分工可能是一个团队专门做业务规则，另一个团队专门做前端的业务规则组装。 抽象工厂模式有助于这样的团队的分工: 两个团队通讯的约定是业务接口，由抽象工厂作为纽带粘合业务规则和前段调用，大大降低了模块间的耦合性，提高了团队开发效率。

“GOF《设计模式》中提出过一种解决方法，即给创建对象的操作增加参数，但这种做法并不能令人满意。事实上，对于新系列加新对象，就我所知，目前还没有完美的做法，只有一些演化的思路，这种变化实在是太剧烈了，因为系统对于新的对象是完全陌生的。”

l         抽象工厂将产品对象的创建延迟到它的具体工厂的子类。

l         如果没有应对“多系列对象创建”的需求变化，则没有必要使用抽象工厂模式，这时候使用简单的静态工厂完全可以。

l         系列对象指的是这些对象之间有相互依赖、或作用的关系，例如游戏开发场景中的“道路”与“房屋”的依赖，“道路”与“地道”的依赖。

l         抽象工厂模式经常和工厂方法模式共同组合来应对“对象创建”的需求变化。

l         通常在运行时刻创建一个具体工厂类的实例，这一具体工厂的创建具有特定实现的产品对象，为创建不同的产品对象，客户应使用不同的具体工厂。

l         把工厂作为单件，一个应用中一般每个产品系列只需一个具体工厂的实例，因此，工厂通常最好实现为一个单件模式。

l         创建产品，抽象工厂仅声明一个创建产品的接口，真正创建产品是由具体产品类创建的，最通常的一个办法是为每一个产品定义一个工厂方法，一个具体的工厂将为每个产品重定义该工厂方法以指定产品，虽然这样的实现很简单，但它确要求每个产品系列都要有一个新的具体工厂子类，即使这些产品系列的差别很小。

l         分离了具体的类。抽象工厂模式帮助你控制一个应用创建的对象的类，因为一个工厂封装创建产品对象的责任和过程。它将客户和类的实现分离，客户通过他们的抽象接口操纵实例，产品的类名也在具体工厂的实现中被分离，它们不出现在客户代码中。

l         它使得易于交换产品系列。一个具体工厂类在一个应用中仅出现一次——即在它初始化的时候。这使得改变一个应用的具体工厂变得很容易。它只需改变具体的工厂即可使用不同的产品配置，这是因为一个抽象工厂创建了一个完整的产品系列，所以整个产品系列会立刻改变。

l         它有利于产品的一致性。当一个系列的产品对象被设计成一起工作时，一个应用一次只能使用同一个系列中的对象，这一点很重要，而抽象工厂很容易实现这一点。

l         难以支持新种类的产品。难以扩展抽象工厂以生产新种类的产品。这是因为抽象工厂几口确定了可以被创建的产品集合，支持新种类的产品就需要扩展该工厂接口，这将涉及抽象工厂类及其所有子类的改变。

l         一个系统不应当依赖于产品类实例如何被创建、组合和表达的细节，这对于所有形态的工厂模式都是重要的。

l         这个系统有多于一个的产品族，而系统只消费其中某一产品族。

l         同属于同一个产品族的产品是在一起使用的，这一约束必须在系统的设计中体现出来。

l         系统提供一个产品类的库，所有的产品以同样的接口出现，从而使客户端不依赖于实现。

l         支持多种观感标准的用户界面工具箱（Kit）。

l         游戏开发中的多风格系列场景，比如道路，房屋，管道等。

l         ……

_____________________________________________________________________________

http://blog.dreambrook.com

《Java与模式》

《设计模式》

《Design  Patterns  Explained》

0
0

* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
个人资料
• 访问：272308次
• 积分：4480
• 等级：
• 排名：第6602名
• 原创：155篇
• 转载：45篇
• 译文：0篇
• 评论：119条
文章分类
评论排行
最新评论
CSDN