设计模式 简单工厂+工厂方法+抽象工厂
简单工厂
简单工厂的优缺点：
缺点：①违反了OCP（开放-封闭原则）。（当工厂内增加一个方法创建对象时候，需要在原来的工厂内，添加一个case语句）。修改原来的类，是违反设计原则的。
②增加客户端和工厂类的耦合。
优点：①去除（非降低）客户端和具体产品的耦合。客户端和具体产品中间增加一个工厂类，增加客户端和工厂类的耦合。
②封装工厂类，实现代码多平台的复用性。创建对象的过程被封装成工厂类，可以多平台（控制台+WEB+Winform...手机端）调用这个工厂。
③封装工厂类，创建对象的过程（具体逻辑）包含必要的逻辑，根据客户端的要求，我们可以动态的去创建对象。比如用反射或者new的方式来创建。
“产品”类
public class PersonClass
{
public string Name { get; set; }
public double Height { get; set; }
}
class WhitePerClass : PersonClass
{
}
class BlackPerClass : PersonClass
{
}
class YellowPerClass : PersonClass
{
}
“工厂”类：
public static class ClassFactory
{
public static PersonClass CreateObject(string str)
{
PersonClass perClass = null;
//也可以用反射等逻辑来创建对象。客户端调用时，是管不到我怎么样创建对象的。这是封装的好处之一。
switch (str)
{
case "white":
perClass = new WhitePerClass();
break;
case "black":
perClass = new BlackPerClass();
break;
case "yellow":
perClass = new YellowPerClass();
break;
}
return perClass;
}
}
}
“客户端”：
static void Main(string[] args)
{
//PersonClass perWhite = new WhitePerClass();//虽然“产品”类PersonClass，采用了面向高层的方法，不用工厂创建对象，还是有一定的耦合。
PersonClass perClass = null;
perClass = ClassFactory.CreateObject("white");
perClass.Name = "小白";
perClass.Height = 1.7;
Console.WriteLine(perClass.Name + perClass.Height);
perClass = ClassFactory.CreateObject("black");
perClass.Name = "小黑";
perClass.Height = 2.1;
Console.WriteLine(perClass.Name + perClass.Height);
perClass = ClassFactory.CreateObject("yellow");
perClass.Name = "小黄";
perClass.Height = 1.8;
Console.WriteLine(perClass.Name + perClass.Height);
Console.Read();
}
结果：
再述简单工厂：
产品本身采用了多态。可以new一个产品出来，这样本身降低了客户端和“产品”的耦合，但是未去除耦合。由工厂进一步去除耦合。
缺点：当增加一个产品时，需要在工厂添加一个case语句，修改了原来工厂类。违反了OCP开放封闭原则。
总结简单工厂：
给工厂传一个字符串，返回一个对象。创建逻辑各式各样。
产品树（产品等级）+产品族
都是指的产品。根据品牌和生产厂家分类。
产品树（产品等级）：针对产品。指一个产品：品牌不同。
①车（产品）：宝马车，奥迪车，奥拓车。
②数据库（产品）：MS-SQL，ORACLE，ACCESS，DB2，MongoDB
产品族：针对工厂。一个工厂，产各种产品，各种产品统称一“族”。
①宝马（工厂）生产：宝马自行车，宝马三轮车0.0，宝马的其他产品，衣服，鞋子，宝箱等等。都是一族
②MS-SQL（工厂）生产: user表，department表，role表
工厂方法
特点：只处理一个产品树。可以理解为，只对一张表处理。也是和下面的抽象工厂区别的地方
优点：就是解决简单工厂的缺点（违反了OCP）。和抽象工厂一样，提高程序的扩展性，可以改数据库。增加对应数据库工厂。
缺点：不能增加一个“产品”，只能增加一个工厂，实现了换数据库的功能。但只能处理一个表。若增加一个表就是抽象工厂了。
类图：
个人总结：我们平时用到了工厂模式，一般属于简单工厂或者抽象工厂，因为可以对多个表处理。
抽象工厂：
优点：去除了简单工厂的违反OCP原则，通过添加子类，而不是改变原来类。来增加”产品“。
缺点：每增加一个产品：需要添加一个产品接口+sql产品+oracle产品，还要增加工厂接口+sql工厂+oracle工厂的一个方法。
“产品“类
用户：
interface IUserDal
{
void CRUD();
}
class SqlUserDal : IUserDal
{
public void CRUD()
{
Console.WriteLine("sql数据库User的CRUD");
}
}
class OracleUserDal : IUserDal
{
public void CRUD()
{
Console.WriteLine("Oracle数据库User的CRUD");
}
}
部门：
interface IDepartmentDal
{
void CRUD();
}
class SqlDepartmentDal : IDepartmentDal
{
public void CRUD()
{
Console.WriteLine("sql数据库Department的CRUD");
}
}
class OracleDepartmentDal : IDepartmentDal
{
public void CRUD()
{
Console.WriteLine("Oracle数据库Department的CRUD");
}
}
”工厂“类
interface IFactory
{
IUserDal CreateUserDal();
IDepartmentDal CreateDepartmentDal();
}
class SqlFactory : IFactory
{
public IUserDal CreateUserDal()
{
return new SqlUserDal();
}
public IDepartmentDal CreateDepartmentDal()
{
return new SqlDepartmentDal();
}
}
class OracleFactory : IFactory
{
public IUserDal CreateUserDal()
{
return new OracleUserDal();
}
public IDepartmentDal CreateDepartmentDal()
{
return new OracleDepartmentDal();
}
}
客户端：
static void Main(string[] args)
{
//创建Sql对应dal
SqlFactory sqlFactory=new SqlFactory();
IUserDal sqlUserDal = sqlFactory.CreateUserDal();
sqlUserDal.CRUD();
IDepartmentDal sqlDeparmentDal = sqlFactory.CreateDepartmentDal();
sqlDeparmentDal.CRUD();
//换数据库了，需要创建Oracle对应Dal
OracleFactory oracleFactory = new OracleFactory();
IUserDal oracleUserDal = oracleFactory.CreateUserDal();
oracleUserDal.CRUD();
IDepartmentDal oracleDeparmentDal = oracleFactory.CreateDepartmentDal();
oracleDeparmentDal.CRUD();
Console.Read();
}
结果：
总结：
①理解产品族和产品树（产品等级），方便记忆类图。
②知道工厂方法和抽象工厂的区别
③工厂方法和抽象工厂改善了简单工厂的缺点（违反ocp），带来的缺点是什么。
为了改变抽象工厂增加一个”产品“，带来的繁琐代码，你想到怎么改进了吗？