C#设计模式：六大原则（上）

子类必须完全实现父类的属性和方法，如果子类不拥有父类的全部属性或者行为，不能强行继承，要断掉继承。
子类可以拥有父类没有的属性或者方法，子类出现的地方，父类不能代替。

一直在纠结举个什么例子，还是拿鸟来说事吧，通俗易懂。先看个反例，鸟类都需要吃东西，都需要喝水，还可以飞，代码如下：

public class Bird
{
    public string Name => this.GetType().Name;

    public void Eat()
    {
        Console.WriteLine($"我是{this.Name}，我需要吃东西");
    }

    public void Drink()
    {
        Console.WriteLine($"我是{this.Name}，我需要喝水");
    }

    public void Fly()
    {
        Console.WriteLine($"我是{this.Name}，我可以飞");
    }
}

/// 
/// 现在来了只比较大的鸟，叫鸵鸟，继承了鸟类
/// 
public class Ostrich : Bird
{
    //Do nothing
}

调用一下

class Program
{
    static void Main(string[] args)
    {
        try
        {
            Bird bird = new Ostrich();
            bird.Eat();
            bird.Drink();
            bird.Fly();
        }
        catch (Exception e)
        {
            Console.WriteLine(e.Message);
        }
        Console.Read();
    }
}

运行结果：
我是Ostrich，我需要吃东西
我是Ostrich，我需要喝水
我是Ostrich，我可以飞

是不是出问题了，鸵鸟显然是不能飞的，也继承了鸟类，这就违背了里氏替换原则。鸵鸟虽然是鸟类，可不能飞，比较特珠，就需要断掉继承。鸵鸟这是说话了，我不能飞，我也要吃和喝啊，怎么办？那你都不属于动物吗，我们来使用里氏替换原则重构一下：

图2.1 重构后的类图

类图不复杂，很容易理解，抽出一个共同的基类动物，然后继承各自的功能，互不影响，根据需求还可以有自己的方法，孔雀可以开屏了。
到这里，你是不是看出点什么问题了，如果父类有什么改动或需要去除一个方法什么的，这就麻烦了，这就是里氏替换的一个缺陷了：继承是侵入式的，代码灵活性受到限制，增强了耦合性。
代码如下：

public class Animal
{
    public string Name => this.GetType().Name;

    public void Eat()
    {
        Console.WriteLine($"我是{this.Name}，我需要吃东西");
    }

    public void Drink()
    {
        Console.WriteLine($"我是{this.Name}，我需要喝水");
    }
}

public class Bird : Animal
{
    /// 
    /// 鸟有自己可以飞的方法
    /// 
    public void Fly()
    {
        Console.WriteLine($"我是{this.Name}，我可以飞");
    }
}

public class Ostrich : Animal
{
    //do nothing
}

public class Sparrow : Bird
{
    //do nothing
}

public class Peacock : Bird
{
    /// 
    /// 孔雀可以开屏
    /// 
    public void Open()
    {
        Console.WriteLine($"我是{this.Name}，我要开屏了，我不是老孔雀");
    }
}

调用如下

class Program
{
    static void Main(string[] args)
    {
        try
        {
            {
                Bird bird = new Sparrow();
                bird.Fly();  //可以飞
            }

            {
                //Bird bird = new Peacock(); //子类出现的地方父类不能代替
                Peacock bird = new Peacock();
                bird.Fly();
                bird.Open();
            }
        }
        catch (Exception e)
        {
            Console.WriteLine(e.Message);
        }
        Console.Read();
    }
}

三、依赖倒置原则（Dependence Inversion Principle，DIP）

高层模块不应该依赖低层模块，两者都应该依赖其抽象，不要依赖细节

在C#中，抽象就是指接口或者抽象类，两者都不能直接进行实例化；细节就是实现类，就是实现了接口或继承了抽象类而产生的类就是实现类，可以直接被实例化。所谓的高层与低层，每个逻辑实现都是由原始逻辑组成，原始逻辑就属于低层模块，像我们常说的三层架构，业务逻辑层相对数据层，数据层就属于低层模块，业务逻辑层就属于高层模块，是相对来说的。依赖倒置原则就是程序逻辑在传递参数或关联关系时，尽量引用高层次的抽象，不使用具体的类，即是使用接口或抽象类来引用参数，声明变量以及处理方法返回值等。这样就要求具体的类就尽量不要有多余的方法，否则就调用不到。说简单点，就是“面向接口编程”。
现在学车很流行，驾校也很多（学习的车是真心的破旧），我当时都是些老捷达，皇冠之类的，根据依赖倒置的原则，我们来实现下这个过程，如图3.1

图3.1 依赖倒置原则的类图

一个学生的抽象类，一个汽车的接口，分别定义了各自的职能，具体代码如下：

public interface ICar
{
    /// 
    /// 汽车是可以开动的
    /// 
    void Run();
}

public class Jetta : ICar
{
    public void Run()
    {
        Console.WriteLine("捷达车开动起来了...");
    }
}

public class Crown : ICar
{
    public void Run()
    {
        Console.WriteLine("皇冠车开动起来了...");
    }
}

/// 
/// 用的抽象方法，考虑学员会有共性的内容
/// 
public abstract class BaseStudent
{
    public string Name { get; set; }

    /// 
    /// 给个构造函数，用来初始化名子
    /// 
    /// 
    protected BaseStudent(string name)
    {
        this.Name = name;
    }

    /// 
    /// 学员要学习开车
    /// 这里用的是虚方法，实现可确定的基本操作
    /// 由于每个学员学习过程可能不同，可进行重写操作
    /// 
    /// 
    public virtual void LearnDrive(ICar car)
    {
        Console.WriteLine($"{this.Name}开始学车了");
        car.Run();
    }
}

public class Student : BaseStudent
{
    public Student(string name) : base(name)
    {
    }

    /// 
    /// 学员学习开车，只依赖了抽象（ICar接口）
    /// 
    /// 
    public override void LearnDrive(ICar car)
    {
        //加入自己的内容
        Console.WriteLine($"{this.Name}有些紧张，调整了下情绪");
        base.LearnDrive(car);
    }
}

在我们的场景中，代码如下所示

class Program
{
    static void Main(string[] args)
    {
        try
        {
            //张三开皇冠车都是依赖上层抽象
            //不同的学员开不同的车，就很容易处理了...
            BaseStudent student = new Student("张三");
            ICar car = new Jetta();
            student.LearnDrive(car);

            //张三开皇冠车
            ICar crown = new Crown();
            student.LearnDrive(crown);
        }
        catch (Exception e)
        {
            Console.WriteLine(e.Message);
        }
        Console.Read();
    }
}

运行结果，就不贴出来了。这里注意到了没有，是不是有些地方很熟悉，这不就是里氏替换原则吗？其实，它们之间是相辅相成的，里氏替换是基础，依赖倒置是方法和手段。刚开始了解设计模式时，我就被这两个原则之间整的有点迷惑了，在代码设计的过程中，它们基本上都是同时出现的。

C#设计模式：六大原则（上）

一、 单一职责（Single Reponsibility Principle，SRP）

二、里氏替换原则（Liskov Substitution Principle，LSP）

三、依赖倒置原则（Dependence Inversion Principle，DIP）

你可能感兴趣的:(C#设计模式：六大原则（上）)

一、单一职责（Single Reponsibility Principle，SRP）