同上一篇,难免有错误,希望各位大牛及时指出~
这个模式类似于简单工厂的改良版。
大体的模型分四个:两个工厂,一个工厂基类(接口抽象具体都行?),一个几成基类的具体工厂类,产品同上一个。
这个模式的好处就在于new出产品的工厂方法不止在一个工厂类里面,而是每一个具体工厂类对应一个具体的产品,使得在添加删除产品的时候只需要添加删除类即可。
但是这个模式的缺点就是由于工厂产品类一定是成对出现的,所以占用空间,而且当产品很多的时候,会出现很多对工厂产品的类。
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace ConsoleTempCS
{
class Program
{
interface logger//产品接口 后面的产品都将继承这个接口
{
void writer();
}
class logger1 : logger//产品1
{
public void writer()//实现接口
{
Console.WriteLine("logger1 write()");
}
}
class logger2 : logger//产品2
{
public void writer()//实现接口
{
Console.WriteLine("logger2 write()");
}
}
interface factory//工厂接口,所有工厂都将继承这个接口
{
logger CreateLogger();
}
class factory1 : factory//工厂1,对应生产产品1
{
public logger CreateLogger()//生成产品1
{
logger1 l = new logger1();
return l;
}
}
class factory2 : factory//工厂2,对应生产产品2
{
public logger CreateLogger()//生成产品2
{
logger2 l = new logger2();
return l;
}
}
static void Main(string[] args)//客户测试端
{
factory f;
logger l;
f = new factory1();//这里选择工厂1
l = f.CreateLogger();
l.writer();
}
}
}
隐藏工厂方法,既在工厂类中添加一个方法,该方法中调用CreateLogger方法和产品的writer()方法。
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace ConsoleTempCS
{
class Program
{
interface logger//产品接口 后面的产品都将继承这个接口
{
void writer();
}
class logger1 : logger//产品1
{
public void writer()//实现接口
{
Console.WriteLine("logger1 write()");
}
}
class logger2 : logger//产品2
{
public void writer()//实现接口
{
Console.WriteLine("logger2 write()");
}
}
abstract class factory//不在设为接口的原因是 既然要隐藏CreateLogger方法就要把该方法属性设为protected 所以接口不再适用
{
abstract protected logger CreateLogger();
abstract public void writer();
}
class factory1 : factory//工厂1,对应生产产品1
{
logger1 l;
protected override logger CreateLogger()//生成产品1
{
logger1 l = new logger1();
return l;
}
public override void writer()
{
l = CreateLogger() as logger1;
l.writer();
}
}
class factory2 : factory//工厂2,对应生产产品2
{
logger2 l;
protected override logger CreateLogger()//生成产品2
{
logger2 l = new logger2();
return l;
}
public override void writer()
{
l=CreateLogger() as logger2;
l.writer();
}
}
static void Main(string[] args)//客户测试端
{
factory f;
f = new factory1();//这里选择工厂1
f.writer();
}
}
}
这个模式的好处就在于new出产品的工厂方法不止在一个工厂类里面,而是每一个具体工厂类对应一个具体的产品,使得在添加删除产品的时候只需要添加删除类即可,无需更改父类,与简单工厂方法相同的是,客户无需知道产品的类名,只要知道工厂即可。
但是这个模式的缺点就是由于工厂产品类一定是成对出现的,所以占用空间,而且当产品很多的时候,会出现很多对工厂产品的类。