设计模式之一 简单工厂模式

今天分享设计模式中最简单的一种模式 简单工厂模式。先从面向对象说起，面向对象有三大特性：继承，封装，多态。

 

 

 

所谓封装：在面向对象语言中，我们都是以类来组织代码，类中定义了属性和方法，我们在调用的时候只需要去使用对象的方法名或者属性名就可以了，而不必甚至不需要知道方法的具体实现，类比生活中的例子，榨汁机。我们只知道用它可以榨果汁，放个苹果给我们一杯苹果汁，放个桔子给我们一杯桔子汁就可以了。我们不必要去关心 榨汁机是怎么去工作的。

所谓继承：就是子类继承了父类，父类所有的非私有的方法和属性，子类都可以拿来直接使用。就好比生活中，父亲给儿子留了一笔遗产。你可以直接使用这笔钱而不需要去创造这笔钱然后在去使用。

所谓多态：一个类可以有多个子类，而每个子类只能由一个父类，就好比。一个父亲可以有多个儿子，而每个儿子只可以有一个父亲。对于多态我们有2种理解。第一种是不同的人对同一件事所做的不同反应，例如 工作，对于农民来说就是种地，科学家 搞科研，工人 上班，学生 做作业。第二种是同一个人 在不同情况下，具有不同的身份和角色，例如 同样是你，在公司你可能是员工，在家里 你是你父母的儿子，在路上你是行人。

先来看一个简单的例子：

我们首先定义一个父类Person类：

    /// <summary>
    /// 定义父类Person
    /// </summary>
    public class Person
    {
        public string Name { get; set; }
        public int Age { get; set; }

        /// <summary>
        /// 自我介绍
        /// </summary>
        public void SayHi()
        {
            Console.WriteLine("大家好我是" + Name + ",我今年" + Age + "岁了!");
        }
    }

 

 定义2个子类，一个Student类，一个Teacher类

 public class Student : Person
    {
    }

 

 public class Teacher: Person
    {
    }

 

在控制台中访问：

 static void Main(string[] args)
        {
            Student s = new Student();
            s.Name = "张三";
            s.Age = 20;
            s.SayHi();
        }

 

输出：

 

可以看出子类是可以使用父类的非私有的属性和方法。

当然 老师的自我介绍和学生自我介绍肯定不一样。如果我们要实现 老师的自我介绍是 大家好。我是XX老师，我今年工作几年了。 学生的自我介绍是大家好。我是某某学生，我今年多少岁了，应该怎么做呢。

如下图：

 

编译器会有警告，因为我们在基类中已经使用了SayHi方法来做自我介绍。为了能更好的解决问题。我们就要用到多态了。

我们把基类Person类改写成抽象类，把基类中的SayHi方法改写成抽象方法。

 

直接上图：

 

 /// 定义父类Person
    /// </summary>
    public abstract class Person
    {
        public string Name { get; set; }
        public int Age { get; set; }

        /// <summary>
        /// 自我介绍
        /// </summary>
        //public void SayHi()
        //{
           // Console.WriteLine("大家好我是" + Name + ",我今年" + Age + "岁了!");
        //}
        /// <summary>
        /// 抽象方法，自我介绍
        /// 抽象方法没有具体实现，只能通过子类覆写来实现。
        /// </summary>
        public abstract void SayHi();
    }

子类

 

 public class Teacher : Person
    {
        public int YearOfWork { get; set; }

        public override void SayHi()
        {
            Console.WriteLine("大家好我是" + Name + "老师,我工作" + YearOfWork + "年了!");
        }
    }

 

 

 public class Student : Person
    {
        /// <summary>
        /// 重写基类自我介绍方法
        /// </summary>
        public override void SayHi()
        {
            Console.WriteLine("大家好我是" + Name + ",我今年" + Age + "岁了!");
        }
    }

 

在Main方法中 定义如下

 

 

static void Main(string[] args)
        {
            Teacher t = new Teacher();
            t.Name = "AAA";
            t.YearOfWork = 5;
            t.SayHi();

            Person p = new Teacher() { Age = 18, Name = "李四", YearOfWork = 5 };
            p.SayHi();
        }

 

输出结果

 

如上图 我们可以看到 p 和t 都是调用的teacher类中的sayhi方法。 这就是多态。子类通过覆写 父类中的抽象方法或者虚方法来实现。

这个也叫里氏替换原则 就是凡是父类出现的地方子类都可以出现。 试想一下 如果 Person类不定义为抽象类。以上2个输出结果会有什么不同。

简单工厂正是 基于以上原则来实现的。

以上是对面向对象的一个简单回顾。下面我们来讲 简单工厂设计模式。设计模式不是一种新的技术，只是在编写代码中一些好的方式的积累和经验的积累。

 

 从上图 我们可以看出：

从结构可以看出，工厂依赖于所有的子类产品，客户只需知道父类产品和工厂即可。工厂是整个模式的核心，以不变应万变。

在现实生活中 我们知道。工厂是用来生产产品的。在面向对象的技术里面工厂也是用来生产产品的。在这里我们的工厂是用来给类生产对象的。

在前面我们简单介绍过封装 继承 多态。那么在使用简单工厂模式的时候我们首先要定义好角色。父类 ，子类 和工厂类。 子类继承父类。 父类定义子类要实现的方法。工厂 创建类的对象。客户调用的时候只需要 知道工厂类和父类就可以了。上图红线标注。

 

我们以生活中的例子来说明。

首先我们创建一个父类 。我们知道车有很多。什么宝马 奔驰。等等。我们先定义一个父类 。小汽车类

 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Demo
{
    /// <summary>
    /// 父类
    /// </summary>
    public abstract class Car
    {
        public abstract void Run();
    }
}

 

在来定义2个子类 ，子类继承父类

一个是宝马汽车类：

/// <summary>
    /// 子类1
    /// </summary>
   public class BMWCar:Car
    {
        public override void Run()
        {
            Console.WriteLine("宝马轿车在行驶！");
        }
    }

    /// <summary>
    /// 子类2
    /// </summary>
    public class BenzCar:Car
    {
        public override void Run()
        {
            Console.WriteLine("奔驰轿车在行驶！");
        }
    }

在来定义一个工厂类

 /// <summary>
    /// 工厂
    /// </summary>
   public class Factory
    {
       public static Car CreateCar(string carType)
       {
           Car car = null;
           switch (carType)
           {
               case "BMW":
                   car = new BMWCar();
                   break;
               case "Benz":
                   car = new BenzCar();
                   break;
           }
           return car;
       }
    }

 

在工厂类中。我们定义了一来Create方法。用来创建对象。通过父类对象来返回我们创建的对象。

在Main方法 中调用 就是上图中的客户端。我们只需要关注父类和工厂 。

 Car car = Factory.CreateCar("Benz");
 car.Run();

运行结果 就是 ：奔驰汽车在行驶。