赞
踩
工厂模式是一种创建对象的设计模式,主要的是将对象的创建和使用分离的一种方法,可以在不知道实现的情况下创建具体的对象,举个例子,比如一个工厂是做包装的,我不需要知道工厂内部是怎么实现的,我只需要传入产品,返回给我一个包装好的物品就行。工厂模式有三种变体,简单工厂模式,工厂方法模式,抽象工厂模式,如下。(以下环境不是unity,是C#的控制台程序)
需求:
有一个工厂做包装生意,现有苹果,香蕉,桃子,请将各个水果包装好运出来。
- internal class Program
- {
- private static void Main(string[] args)
- {
- IPack pack = FruitFactory.FactorPack("Peach");
- pack.PackFruit();
- }
- }
- public interface IPack//打包接口
- {
- void PackFruit();
- }
- public class Apple : IPack//苹果
- {
- public void PackFruit()
- {
- Console.WriteLine("Pack Appple!");
- }
- }
- public class Banana : IPack//香蕉
- {
- public void PackFruit()
- {
- Console.WriteLine("Pack Banana!");
- }
- }
- public class Peach : IPack//桃子
- {
- public void PackFruit()
- {
- Console.WriteLine("Pack Peach!");
- }
- }
- public class FruitFactory//水果工厂
- {
- public static IPack FactorPack(string type)
- {
- switch (type)
- {
- case "Appple":
- return new Apple();
- case "Banana":
- return new Banana();
- case "Peach":
- return new Peach();
- default:
- throw new Exception("无效类型");
- }
- }
- }
输出结果:Pack Peach!
简单工厂:简单来说就是通过继承接口,实现各种类型的扩展,然后通过一个统一的工厂方法管理起来,但是修改的话需要修改工厂方法(如上FactorPack),不满足开闭原则。
扩展的话需要加入新的类,然后在工厂方法中添加具体的类型。具体的实现可以放在对应的方法类,当然也可以带入参数,具体业务逻辑的扩展,按实际的需求来。
- internal class Program
- {
- private static void Main(string[] args)
- {
- CreatorFactor pack = new PeachFactory();
- IPack peach = pack.FactoryMethod();
- peach.PackFruit();
- }
- }
- public interface IPack//打包接口
- {
- void PackFruit();
- }
- public class Apple : IPack//苹果
- {
- public void PackFruit()
- {
- Console.WriteLine("Pack Appple!");
- }
- }
- public class Banana : IPack//香蕉
- {
- public void PackFruit()
- {
- Console.WriteLine("Pack Banana!");
- }
- }
- public class Peach : IPack//桃子
- {
- public void PackFruit()
- {
- Console.WriteLine("Pack Peach!");
- }
- }
- public abstract class CreatorFactor//工厂抽象类
- {
- public abstract IPack FactoryMethod();
- }
-
- public class AppleFactory : CreatorFactor//苹果工厂
- {
- public override IPack FactoryMethod()
- {
- return new Apple();
- }
- }
- public class BananaFactory : CreatorFactor//香蕉工厂
- {
- public override IPack FactoryMethod()
- {
- return new Banana();
- }
- }
- public class PeachFactory : CreatorFactor//桃子工厂
- {
- public override IPack FactoryMethod()
- {
- return new Peach();
- }
- }
输出结果:Pack Peach!
工厂方法模式:这个办法解决了上述的简单工厂的问题,不满足设计模式原则的开闭原则,工厂方法模式可以在不修改原来代码的情况下扩展新的工厂。简单来说,就是将工厂方法做成了一个抽象类,然后有新的工厂的时候继承自这个抽象类,实现对应的方法。
扩展的话,只需要扩展新的类型,然后继承CreatorFactor再实现对应的方法,不用修改原来的方法,缺点就是增加了代码的复杂性,要管理很多的工厂。
这里扩展一下复杂度,现在苹果,香蕉,桃子,现在有两种不同的包装,普通和精美
- internal class Program
- {
- private static void Main(string[] args)
- {
- IFactory factory = new PeachFactory();
- IOrdinaryPack ordinaryPack = factory.PackOridinary();
- IExquisitePack exquisitePack = factory.PackExquisite();
- ordinaryPack.PackOrdinaryFruit();
- exquisitePack.PackExquisiteFruit();
- }
- }
- public interface IOrdinaryPack//普通包装接口
- {
- void PackOrdinaryFruit();//包装普通水果
- }
- public class OrdinaryApple : IOrdinaryPack//普通包装苹果
- {
- public void PackOrdinaryFruit()
- {
- Console.WriteLine("Pack OrdinaryApple!");
- }
- }
- public class OrdinaryBanana : IOrdinaryPack//普通包装香蕉
- {
- public void PackOrdinaryFruit()
- {
- Console.WriteLine("Pack OrdinaryBanana!");
- }
- }
- public class OrdinaryPeach : IOrdinaryPack//普通包装桃子
- {
- public void PackOrdinaryFruit()
- {
- Console.WriteLine("Pack OrdinaryPeach!");
- }
- }
- //----------------------------------------------------------------------------
- public interface IExquisitePack//精美包装接口
- {
- void PackExquisiteFruit();//包装精美水果
- }
- public class ExquisiteApple : IExquisitePack//精美包装苹果
- {
- public void PackExquisiteFruit()
- {
- Console.WriteLine("Pack ExquisiteApple!");
- }
- }
- public class ExquisiteBanana : IExquisitePack//精美包装香蕉
- {
- public void PackExquisiteFruit()
- {
- Console.WriteLine("Pack ExquisiteBanana!");
- }
- }
- public class ExquisitePeach : IExquisitePack//精美包装桃子
- {
- public void PackExquisiteFruit()
- {
- Console.WriteLine("Pack ExquisitePeach!");
- }
- }
- //----------------------------------------------------------------------------
- public interface IFactory//工厂接口
- {
- IOrdinaryPack PackOridinary();
- IExquisitePack PackExquisite();
- }
- public class AppleFactory : IFactory//苹果工厂
- {
- public IExquisitePack PackExquisite()
- {
- return new ExquisiteApple();
- }
-
- public IOrdinaryPack PackOridinary()
- {
- return new OrdinaryApple();
- }
- }
- public class BananaFactory : IFactory//香蕉工厂
- {
- public IExquisitePack PackExquisite()
- {
- return new ExquisiteBanana();
- }
-
- public IOrdinaryPack PackOridinary()
- {
- return new OrdinaryBanana();
- }
- }
- public class PeachFactory : IFactory//桃子工厂
- {
- public IExquisitePack PackExquisite()
- {
- return new ExquisitePeach();
- }
-
- public IOrdinaryPack PackOridinary()
- {
- return new OrdinaryPeach();
- }
- }
输出结果:
Pack OrdinaryPeach!
Pack ExquisitePeach!
抽象工厂模式:抽象工厂模式是工厂方法模式的一种扩展,仔细看两者相识度是很高的,各有各适用的场景,实际适用按照需求来。
Copyright © 2003-2013 www.wpsshop.cn 版权所有,并保留所有权利。