IT干货网

简单工厂 工厂模式 抽象工厂---C#

developer 2022年03月15日 编程设计 197 0

工厂模式看了很多,属这一篇通俗易懂了。新手建议从这入门。

这篇文章说一下简单工厂,工厂,抽象工厂的概念和应该场景

首先,从简单工厂开始:

见上图,可以看出来,最核心的部分就是工厂类了,所有的变化都封装在这个工厂类里面,Client不用关心类的实例化

但是,可谓成也工厂类,败也工厂类

如果,实例化的对应有所变化,就需要修改核心工厂类,违背了开放-封闭原则(对修改封闭,对扩展开放)

C#版本代码实现

Simple Factory
SimplyFactory 
 
   public abstract class  Simplyfactory 
    { 
         public  abstract   string CreateFactory(); 
 
    } 
    public class SimplyA : Simplyfactory 
    { 
        public override string CreateFactory() 
        { 
            return "FactoryA"; 
        } 
    } 
 
    public class SimplyB : Simplyfactory 
    { 
        public override  string CreateFactory() 
        { 
            return "FactoryB"; 
        } 
    } 
 
    class Factory 
    { 
        public static Simplyfactory Create(string Type)//核心工厂类负责所有对象的创建,属于创建型模式 
        { 
            Simplyfactory s = null; 
            switch (Type) 
            { 
                case "A": 
                    s = new SimplyA(); 
                    break; 
                case "B": 
                    s = new SimplyB(); 
                    break; 
                default: 
                    break; 
            } 
            return s; 
        } 
    } 
 
    class Client 
    { 
        static void GetSimplyFactory() 
        { 
            Simplyfactory simplyfactory = Factory.Create("A"); 
            Console.Write(simplyfactory.CreateFactory()); 
            Console.Read(); 
        } 
    }

输出结果:FactoryA

简单工厂模式(Simple Factory Pattern)属于类的创新型模式,又叫静态工厂方法模式(Static FactoryMethod Pattern),是通过专门定义一个类来负责创建其他类的实例,被创建的实例通常都具有共同的父类

简单工厂模式解决的问题是如何去实例化一个合适的对象。

简单工厂模式的核心思想就是:有一个专门的类来负责创建实例的过程。

好的,下面介绍下工厂模式

先来图

 

定义一个创建对象的抽象类,有子类来决定具体实例化哪个类,使一个类的创建延迟到子类中

创建的对象Product不会变,但是对象的具体实现经常变换,如果发生变化,增加新的FacotoryMethods子类就可以了

满足对开放--封闭原则

 C#版本代码:

FactoryMethod
FactoryMethod 
 
 public abstract class Product 
    { 
        public abstract void work(); 
    } 
    public class ProductA : Product 
    { 
        public override void work() 
        { 
            Console.Write("ProductA"); 
        } 
    } 
    public class ProductB : Product 
    { 
        public override void work() 
        { 
            Console.Write("ProductB"); 
        } 
    } 
 
    public abstract class FactoryMethods 
    { 
        public abstract Product newproduct(); 
    } 
    //对不同产品的实例化,由不同的工厂来具体实现,每一个工厂生产具体的商品 
    public class FactoryMethodA : FactoryMethods//具体工厂 
    { 
        public override Product newproduct() 
        { 
            return new ProductA();//实现具体的实例化 
        } 
    } 
    public class FactoryMethodB : FactoryMethods//具体工厂 
    { 
        public override Product newproduct() 
        { 
            return new ProductB();//实现具体的实例化 
        } 
    } 
 
    public class FactoryMethodClient 
    { 
        public static void GetFactoryMethod() 
        { 
            //产品种类是变化的,如果发生变化,新增一个工厂就可以了,在调用的地方掉用新的方法 
            //体现出对修改封闭,对扩展开放,新增新的功能对原来的没有影响 
            FactoryMethods factorysubA = new FactoryMethodA(); 
            FactoryMethods factorysubB = new FactoryMethodB(); 
 
            Product pruductA = factorysubA.newproduct(); 
            Product pruductB = factorysubB.newproduct(); 
 
            pruductA.work(); 
            pruductB.work(); 
        } 
    }

可以看出来,工厂模式的工厂,实例化的对象只有一个,如果实例化的对象是多个,就成了抽象工厂模式,其实工厂模式和抽象工厂也就这点区别

先来看看抽象工厂的UML图

看到了吧,唯一的区别就是工厂创建了多个对象,当然,还是在工厂子类中创建的,这一点和工厂模式是一致的

C#版本代码

   

AbstractFactory
AbstractFactory 
 
/*其实工厂和抽象工厂没有多大区别,只不过是抽象工厂生产的商品是多个而已 
    通俗的说,就是抽象工厂模式的具体工厂里面会有多个实例具体对象的方法 
    更直观的就是,抽象工厂模式每个工厂一次造多个玩意,而工厂模式的每个工厂只造一个玩意*/ 
    public abstract class Product 
    { 
        public abstract void work(); 
    } 
    public class ProductA : Product 
    { 
        public override void work() 
        { 
            Console.Write("ProductA"); 
        } 
    } 
    public class ProductB : Product 
    { 
        public override void work() 
        { 
            Console.Write("ProductB"); 
        } 
    } 
    public abstract class Car 
    { 
        public abstract void Build(); 
    } 
    public class CarA : Car 
    { 
        public override void Build() 
        { 
            Console.Write("Build CarA"); 
        } 
    } 
    public class CarB : Car 
    { 
        public override void Build() 
        { 
            Console.Write("Build CarB"); 
        } 
    } 
    public abstract class AbstractFactory 
    { 
        //工厂生产多个对象 
        public abstract Product newproduct(); 
        public abstract Car newCar(); 
    } 
    public class AbstractFactoryA : AbstractFactory 
    { 
        public override Product newproduct() 
        { 
            return new ProductA();//子类里面实现具体的实例化 
        } 
        public override Car newCar() 
        { 
            return new CarA(); 
        } 
    } 
    public class AbstractFactoryB : AbstractFactory 
    { 
        public override Product newproduct() 
        { 
            return new ProductB();//子类里面实现具体的实例化 
        } 
        public override Car newCar() 
        { 
            return new CarB(); 
        } 
    } 
 
    public class AbstractFactoryClient 
    { 
        public static void GetFactoryMethod() 
        { 
            AbstractFactory factorysubA = new AbstractFactoryA(); 
            AbstractFactory factorysubB = new AbstractFactoryA(); 
 
            Product pruductA = factorysubA.newproduct(); 
            Product pruductB = factorysubB.newproduct(); 
            Car factorycarA = factorysubA.newCar(); 
 
            factorycarA.Build(); 
 
            pruductA.work(); 
            pruductB.work(); 
        } 
    }

应用场景:封装变化点。创建一系列相互依赖的对象。

好了,到这里就把简单工厂,工厂,抽象工厂都介绍完了,抽象工厂的问题是如果有创建对象变化的时候,还是要变化代码,重新生成,后面会介绍用反射解决这个问题


评论关闭
IT干货网

微信公众号号:IT虾米 (左侧二维码扫一扫)欢迎添加!