Mr_Yang

# 抽象工厂模式（Abstract Factory）

奖金 = 基本工资(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》

#### 【java设计模式】之 抽象工厂（Abstract Factory）模式

2016-04-26 23:49:42

#### 设计模式(创建型)之抽象工厂模式(Abstract Factory Pattern)

2015-04-27 16:46:16

#### 抽象工厂模式（AbstractFactory）-设计模式（二）

2016-08-15 10:39:26

#### 设计模式——抽象工厂模式（Abstract Factory）

2014-08-02 16:52:37

#### 设计模式（2）-抽象工厂模式(Abstract Factory)与生成器模式(Builder)模式

2017-11-06 22:42:24

#### Abstract Factory 抽象工厂模式(创建型模式)

2006-11-28 08:20:00

#### iOS 21种设计模式之抽象工厂（Abstract Factory）

2015-12-07 10:13:51

#### 设计模式之六 --- 抽象工厂模式(Abstract Factory)

2012-03-12 23:46:58

#### 工厂模式(Factory)和抽象工厂模式(AbstractFactory)

2008-07-29 23:20:00

#### 003AbstractFactory.rar

2010年11月11日 17KB 下载