工厂方法模式
姓名：赵汉青
学号：07770201
模式名称：工厂方法模式
1．问题描述
生活场景：很多的公司都通过生产不同品牌的同一类产品来占有市场，比如，联合利华公司生产洗发水，开始只有“夏士莲”系列，后来为了在洗发水市场上扩充份额，又推出了“清扬”系列。你会发现，不管是“清扬”还是“夏士莲”，有着相同的功能——洗发，它们在生产的过程中也有很多共同的地方。
设计目的：实现对具有共性的产品的创建。
2．不假思索的思路
思路描述：在生产“夏士莲”洗发水的工厂里增加一条生产“清扬”洗发水的生产线，以实现“清扬”洗发水的生产。
类结构图：
缺点：这样的设计，工厂类集中了所有的实例的创建逻辑，违反了单一职责原则，即每一个类都只负责一件具体的事情；同时，当产品不断增多时，可能会出现要求工厂类根据不同条件创建不同实例的需求，工厂类就无法满足需求，不利于后续的扩充和维护。
代码：
abstract class Shampoo //抽象的洗发水类
{
public abstract void produce();
}
class HAZELINE : Shampoo //“清扬”洗发水，继承抽象洗发水类
{
public override void produce()
{
Console.WriteLine("夏士莲洗发水");
}
}
class CLEAR : Shampoo //“夏士莲”洗发水，继承抽象洗发水类
{
public override void produce()
{
Console.WriteLine("清扬洗发水");
}
}
class ShampooFactory //洗发水工厂类
{
/// <summary>
/// 用户传入不同的洗发水名称，创建不同类型的洗发水
/// </summary>
/// <param name="type">洗发水名称</param>
/// <returns>返回创建好的洗发水对象</returns>
public Shampoo createShampoo(string type)
{
switch (type.ToLower())
{
case "clear": return new CLEAR();
case "hazeline": return new HAZELINE();
default: return null;
}
}
}
static void Main(string[] args)
{
Shampoo shampoo;
ShampooFactory shampoofactory = new ShampooFactory();
shampoo = shampoofactory.createShampoo("hazeline"); //告诉工厂生产“夏士莲”
shampoo.produce();
shampoo = shampoofactory.createShampoo("clear");//告诉工厂生产“清扬”
shampoo.produce();
}
3．归纳阶段:
思路描述：通过工厂方法模式进行处理：为每种系列的产品建立属于自己的工厂，各种工厂之间是有共性的，可以继承一个抽象的工厂类；各种产品之间也是有共性的，可以继承一个抽象的产品类。
类结构图：
代码：
abstract class Shampoo //抽象的洗发水类
{
public abstract void produce();
}
class HAZELINE : Shampoo //“清扬”洗发水，继承抽象洗发水类
{
public override void produce()
{
Console.WriteLine("夏士莲洗发水");
}
}
class CLEAR : Shampoo //“夏士莲”洗发水，继承抽象洗发水类
{
public override void produce()
{
Console.WriteLine("清扬洗发水");
}
}
abstract class Factory //抽象的洗发水工厂类
{
public abstract Shampoo createShampoo();
}
class HAZELINEfactory : Factory //“夏士莲”洗发水工厂，继承抽象洗发水工厂
{
public override Shampoo createShampoo()
{
Console.Write("生产：");
return new HAZELINE();
}
}
class CLEARfactory : Factory //“清扬”洗发水工厂，继承抽象洗发水工厂
{
public override Shampoo createShampoo()
{
Console.Write("生产：");
return new CLEAR();
}
}
static void Main(string[] args)
{
Shampoo shampoo;
Factory factory = new HAZELINEfactory(); //实例化“夏士莲”工厂
shampoo = factory.createShampoo(); //“夏士莲”工厂只创造夏士莲洗发水
shampoo.produce();
factory = new CLEARfactory(); //实例化“清扬”工厂
shampoo = factory.createShampoo(); //“清扬”工厂只创造清扬洗发水
shampoo.produce();
}
设计体会：
这样的设计降低了工厂类的内聚，满足了类之间的层次关系，又很好的符合了面向对象设计中的单一职责原则，即每一个类都只负责一件具体的事情。当有新的产品加入时，只需要分别继承抽象的工厂类和抽象的产品类，不会对其它产品有任何影响。
4．验证阶段
思路描述：结合上面的例子，增加一个洗发水产品：“力士”
类结构图：
代码：
abstract class Shampoo //抽象的洗发水类
{
public abstract void produce();
}
class HAZELINE : Shampoo //“清扬”洗发水，继承抽象洗发水类
{
public override void produce()
{
Console.WriteLine("夏士莲洗发水");
}
}
class CLEAR : Shampoo //“夏士莲”洗发水，继承抽象洗发水类
{
public override void produce()
{
Console.WriteLine("清扬洗发水");
}
}
class LUX : Shampoo //"力士洗发水",继承抽象洗发水类
{
public override void produce()
{
Console.WriteLine("力士洗发水");
}
}
abstract class Factory //抽象的洗发水工厂类
{
public abstract Shampoo createShampoo();
}
class HAZELINEfactory : Factory //“夏士莲”洗发水工厂，继承抽象洗发水工厂
{
public override Shampoo createShampoo()
{
Console.Write("生产：");
return new HAZELINE();
}
}
class CLEARfactory : Factory //“清扬”洗发水工厂，继承抽象洗发水工厂
{
public override Shampoo createShampoo()
{
Console.Write("生产：");
return new CLEAR();
}
}
class LUXfactory : Factory //“力士”洗发水工厂，继承抽象洗发水工厂
{
public override Shampoo createShampoo()
{
Console.Write("生产：");
return new LUX();
}
}
static void Main(string[] args)
{
Shampoo shampoo;
Factory factory = new HAZELINEfactory(); //实例化“夏士莲”工厂
shampoo = factory.createShampoo(); //“夏士莲”工厂只创造夏士莲洗发水
shampoo.produce();
factory = new CLEARfactory(); //实例化“清扬”工厂
shampoo = factory.createShampoo(); //“清扬”工厂只创造清扬洗发水
shampoo.produce();
factory = new LUXfactory(); //实例化“力士”工厂
shampoo = factory.createShampoo(); //“力士”工厂只创造力力士洗发水
shampoo.produce();
}
5．抽象描述
思路描述：把“共性”提取出来，根据各自的“个性”建立各自的继承共性的实现。
类结构图:
