C#面向对象设计模式纵横谈 学习笔记5 Factory Method 工厂方法(创建型模式)

1、Factory Method工厂方法模式的动机在软件系统中,经常面临着"某个对象"的创建工作;由于需求的变化,这个对象经常面临着剧烈的变化,但是它却拥有比较稳定的接口。如何应对这种变化?如何提供一种"封装机制"来隔离出"这个易变对象"的变化,从而保持系统中"其他依赖该对象的对象"不随着需求改变而改变?

2、Factory Method工厂方法模式的意图:定义一个用于创建对象的接口,让子类决定实例化哪一个类。Factory Method使得一个类的实例化延迟到子类。

现在看看Factory Method的代码实现方式

首先是一个抽象类AbstractCar,代表所有车类型的抽象类

 

public abstract class AbstractCar
{
    
public abstract void StartUp();

    
public abstract void Run();


    
public abstract void Turn(Direction direction);


    
public abstract void Stop();
}


接下来是一个抽象类,代表Car的工厂,由这个类来产生Car

 

public abstract class AbstractCarFactory
{
    
public abstract AbstractCar CreateCar();
}


接下来是一个具体的Car类型,它继承预AbstractCar,并实现了里面的抽象方法

public class HongQiCar : AbstractCar
{
    Enginee enginee1;
    Enginee enginee2;
    Enginee enginee3;
    Enginee enginee4;

    
public override void StartUp()
    
{
    }


    
public override void Run()
    
{
    }


    
public override void Turn(Direction direction)
    
{
    }


    
public override void Stop()
    
{
    }

}


 

那么对应的,就应该有一个红旗Car对应的工厂,它继承于AbstractCarFactory

public class HongQiCarFactory : AbstractCarFactory
{
    
public override AbstractCar CreateCar()
    
{
        
return new HongQiCar();
    }

}

接下来是一个具体使用到Car和CarFactory的Car的测试类

public class CarTestFramework
{
    
public void BuildTestContext(AbstractCarFactory carFactory)
    
{
        AbstractCar car1 
= carFactory.CreateCar();

        AbstractCar car2 
= carFactory.CreateCar();
    }


    
public void DoTest(AbstractCarFactory carFactory)
    
{
        AbstractCar car1 
= carFactory.CreateCar();
        car1.Run();
    }


    
public TestData GetTestData(AbstractCarFactory carFactory)
    
{
        
//....
    }

}


那么上面的代码,我们知道我们使用CarTestFramework的时候,只需要传入一个抽象工厂,由这个工厂来创建对应的car类型

public static void Main()
{
    CarTestFramework ctf 
= new CarTestFramework();
    ctf.BuildTestContext(
new HongQiCarFactory());
}

在这个Main函数里,我们可以通过配置文件l利用反射创建不同的CarFactory的类型

看到这里,觉得Factory Method有点类似于Abstract Factory模式,这里我们对比一下这两个模式

首先是抽象类和抽象工厂类

public abstract class Road
{
}

public abstract class Building
{
}


public abstract class Tunnel
{
}


public abstract class Jungle
{
}


public abstract class FacilitiesFactory
{
    
public abstract Road CreateRoad();
    
public abstract Building CreateBuilding();
    
public abstract Tunnel CreateTunnel();
    
public abstract Jungle CreateJungle();
}


那么派生对象和派生工厂如下

public class ModenRoad : Road
{
}


public class ModenBuilding : Building
{
}


public class ModenTunnel : Tunnel
{
}


public class ModenJungle : Jungle
{
}


public class ModenFacilitiesFactory : FacilitiesFactory
{

    
public override Road CreateRoad()
    
{
        
return new ModenRoad();
    }


    
public override Building CreateBuilding()
    
{
        
return new ModenBuilding();
    }


    
public override Tunnel CreateTunnel()
    
{
        
return new ModenTunnel();
    }


    
public override Jungle CreateJungle()
    
{
        
return new ModenJungle();
    }

}

可以对比到Abstract Factory和Factory Method模式很类似,但是Factory Method是解决单个对象的需求变化,而Abstract Factory解决的是一系列对象的需求变化。

Factory Method模式的几个要点

  • Factory Method模式主要用于隔离类对象的使用者和具体类型之间的耦合关系。面对一个经常变化的具体类型,紧耦合关系会导致软件的脆弱。
  • Factory Method模式通过面向对象的手法,将所要创建的具体对象工作延迟到子类,从而实现一
    种扩展(而非更改)的策略,较好地解决了这种紧耦合关系。
  • Factory Method模式解决"单个对象"的需求变化,Abstract Factory 模式解决"系列对象"的需求变化,Builder模式解决"对象部分"的需求变化。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值