设计模式之Abstract Factory的学习笔记
1、创建型的模式我们说他主要解决的就是一个new的问题,我们
知道,我们通常创建对都是用的new XX()这种方式。
知道,我们通常创建对都是用的new XX()这种方式。
例://在一个游戏场景中要创建一个道路Road对象
Road road=new Road();
Road road=new Road();
但是new 在我们解决一些问题的时候,它本身不能满足我们需求的变化。
很明显的一个问题就是 new 实现依赖(依赖于类的具体实现),
它不能应对“具体实例化类型”的变化。
它不能应对“具体实例化类型”的变化。
什么意思呢?
比如说那上面的列子来说,在游戏场景中,我们的道路有可能会
场景的需要进行变化,比如我要换一个水泥路,我要换一个木质的路,
这种个种各样的变化它就不能应对这种变化。
比如说那上面的列子来说,在游戏场景中,我们的道路有可能会
场景的需要进行变化,比如我要换一个水泥路,我要换一个木质的路,
这种个种各样的变化它就不能应对这种变化。
2、 解决思路:
---封装变化点 :哪里变化,封装哪里。(面向对象的核心)
---潜台词:如果没有变化,当然不需要额外的封装。
好的面向对象所追寻的原则 变化点在“对象创建”,因此就封装“对象创建”
面向接口编程------依赖接口,而非依赖实现。
最简单的解决方法:
//封装路的创建方式。
class RoadFactory
{
public static Road CreateRoad()
{
//变化点进行封装。面对新的需求我们只在这里改就行了。
return new Road();//return new WaterRoad()--一个泥淋的路
}
}
//封装路的创建方式。
class RoadFactory
{
public static Road CreateRoad()
{
//变化点进行封装。面对新的需求我们只在这里改就行了。
return new Road();//return new WaterRoad()--一个泥淋的路
}
}
===========================================================
//客户程序(使用这个路)
Road road=
RoadFactory.CreateRoad();
//客户程序(使用这个路)
Road road=
RoadFactory.CreateRoad();
3、上面的代码只是一个简单的封装。下面进行延深
假设一个游戏开发场景:我们需要构造“道路”,“房屋”,“地道”,
“丛林”,......等等对象。
假设一个游戏开发场景:我们需要构造“道路”,“房屋”,“地道”,
“丛林”,......等等对象。
Road road=roadFactory.CreateRoad();
............. 这一块的代码又相对稳定了。
Building building=roadFactory.CreateBuildng();
............. 这一块的代码又相对稳定了。
Building building=roadFactory.CreateBuildng();
===============
class RoadFractory
{
//建立道路
public static Road CreateRoad()
{
return new Road();
}
//建立房屋
public static Bluilding CreateBluilding()
{
return new Building();
}
//建立地道
public static Tunnel CreateTunnel()
{
return new Tunnel();
}
class RoadFractory
{
//建立道路
public static Road CreateRoad()
{
return new Road();
}
//建立房屋
public static Bluilding CreateBluilding()
{
return new Building();
}
//建立地道
public static Tunnel CreateTunnel()
{
return new Tunnel();
}
//建立丛林
public static Jungle CreateJungle()
{
return new Jungle();
}
}
一系列相互依赖的对象。比如说地道从屋子里通道丛林中。它们之间就存在着
相互依赖的对象。
public static Jungle CreateJungle()
{
return new Jungle();
}
}
一系列相互依赖的对象。比如说地道从屋子里通道丛林中。它们之间就存在着
相互依赖的对象。
4、简单工厂的问题:
上面的代码又出现问题了,比如说房屋,道路....又要变成不同风格的房屋,道路,
那么上面静态方法创建的房屋道路等等对象又成了变化点了。
上面的代码又出现问题了,比如说房屋,道路....又要变成不同风格的房屋,道路,
那么上面静态方法创建的房屋道路等等对象又成了变化点了。
如果一个系列上面的静态工厂就可以解决了。多个系列静态工厂就不能满足需求。
如何解决呢?
这才引出来我们今天要学习的,使用面向对象的技术来“封装变化点”
动机(Motivation)
在软件系统中,经常面临着“一系列相互依赖的对象”的创建工作;同
时,由于需求的变化,往往存在更多系列的对象的创建工作。
这才引出来我们今天要学习的,使用面向对象的技术来“封装变化点”
动机(Motivation)
在软件系统中,经常面临着“一系列相互依赖的对象”的创建工作;同
时,由于需求的变化,往往存在更多系列的对象的创建工作。
如何应对这种变化?如何绕过常规的对象创建方法(new)提供一种
“封装机制”来避免客户程序和这种“多系列具体对象创建工作的”紧耦合?
“封装机制”来避免客户程序和这种“多系列具体对象创建工作的”紧耦合?
5、抽象工厂
//路
public abstract class Road
{
public abstract void AAA()
{..........}
}
//房屋
public abstract class Buliding
{
}
public abstract class Road
{
public abstract void AAA()
{..........}
}
//房屋
public abstract class Buliding
{
}
//地道
public abstract class Tunnel
{
}
//丛林
public abstract class JSSungle
{
}
abstract class FacilitiesFractory
{
public abstract Road CreateRoad();
public abstract Buliding CreateBuliding();
public abstract Tunnel CreateTunnel();
public abstract Jungle CreateJungle();
}
public abstract class JSSungle
{
}
abstract class FacilitiesFractory
{
public abstract Road CreateRoad();
public abstract Buliding CreateBuliding();
public abstract Tunnel CreateTunnel();
public abstract Jungle CreateJungle();
}
//客户的代码 最大的依赖抽象类 不依赖实现
class GameManager
{
//这个类相对稳定
FacilitiesFractory facilitiesFractory;
Road road;
Buliding buliding;
Tunnel tunnel;
Jungle jungle;
public GameManager(FacilitiesFractory facilitiesFractory)
{
this.facilitiesFractory=FacilitiesFractory;
}
class GameManager
{
//这个类相对稳定
FacilitiesFractory facilitiesFractory;
Road road;
Buliding buliding;
Tunnel tunnel;
Jungle jungle;
public GameManager(FacilitiesFractory facilitiesFractory)
{
this.facilitiesFractory=FacilitiesFractory;
}
public void BulidGameFacilities()
{
road=facilitiesFractory.CreateRoad();
buliding=facilitiesFractory.CreateBuliding();
tunnel=facilitiesFractory.CreateTunnel();
jungle=facilitiesFractory.CreateJungle();
}
public void run()
{
road.AAA();
buliding.BBB(road);
tunnel.CCC();
jungle.DDD(tunnel);
}
}
{
road=facilitiesFractory.CreateRoad();
buliding=facilitiesFractory.CreateBuliding();
tunnel=facilitiesFractory.CreateTunnel();
jungle=facilitiesFractory.CreateJungle();
}
public void run()
{
road.AAA();
buliding.BBB(road);
tunnel.CCC();
jungle.DDD(tunnel);
}
}
//各个对象的具体类
//路
public class ModernRoad:Road
{
}
//房屋
public class ModernBuliding:Buliding
{
}
//地道
public class ModernTunnel:TunnelSS
{
}
//丛林
public class Modernjungle:Jungle
{
}
public class Modernjungle:Jungle
{
}
//具体实现
public class ModernFacilitiesFractory:FacilitiesFractory
{
public override Road CreateRoad(){return new ModrenRoad();}
public override Buliding CreateBuliding(){return new ModrenBuliding()}
public override Tunnel CreateTunnel(){return new ModrenTunnle();}
public override Jungle CreateJungle(){return new ModrenJungle();}
}
//主调类
class App
{
public static void Main()
{
GameManager g=new GamManage(new ModernFacilitiesFractory());
g.BulidGameFaclities();
g.run();
}
}
6、要点
如果没有多个系列对象构建的需求变化,则没有必要使用Abstract Factroy,
使用简单的静态工厂完全可以。
如果没有多个系列对象构建的需求变化,则没有必要使用Abstract Factroy,
使用简单的静态工厂完全可以。
系列对象指的是这些对象之间有相互依赖,或作用的关系。
Abstract factory 模式主要在于应对新系列的需求变动。其缺点在于难以对新
对象的需求变动。
Abstract factory模式经常和Factory Mothod 模式共同组合来应对“对象创建”
的需求变化。
Abstract factory 模式主要在于应对新系列的需求变动。其缺点在于难以对新
对象的需求变动。
Abstract factory模式经常和Factory Mothod 模式共同组合来应对“对象创建”
的需求变化。