面向对象编程OOP

    这节讲一下，什么是面向对象(Object Oriented Programming)。说面向对象之前，我们不得不提的是面向过程（Process Oriented Programming），C语言就是面向过程的语言，这两者的区别在哪呢？我们可以设想一个情景——厨房做菜：

    以面向过程的形式解释来说，第一步：准备材料，第二步：起火，第三步：炒菜，第四步：上菜；面向过程就是编写一个个函数，每个函数执行一部分操作，最后根据这一套函数，执行下来完成一个整体需求为目的。

    那面向对象呢，我们同样的解释做菜说，第一步：要有厨师，灶台，要有服务生，第二步：厨师准备材料，第三步：灶台起火，第四步：厨师炒菜，第五步：服务生上菜。面向对象的编程方式，将原本各个独立的函数，用它所属的对象规整了起来,并封装成方法（面向对象中的"函数"有个新的称呼叫方法Method）。虽然实际上代码量会变多，但是这种编程思维是合情合理的，符合实际的，让人更容易理解，因为每个对象的职责是明确的，从而后期维护会变得更方便。

    下面在代码层面，演示一下面向对象和面向过程的区别：

    过程化：

#include "stdio.h"
​
void Prepare(){
  printf("准备食材。
");
}
void Fire(){
  printf("起火
");
}
void Cooking(){
  printf("炒菜，
");
  printf("炒完了
");
}
void Serve(){
  printf("请享用。");
}
​
main(){
  Prepare();
  Fire();
  Cooking();
  Serve(); 
}

 对象化：

//创建三个对象
//厨师
class Cook
{
    //准备食材的方法
    public void Prepare()
    {
        Console.WriteLine("厨师准备食材。");
    }
    //做饭的方法
    public void Cooking()
    {
        Console.WriteLine("厨师正在做饭...");
        Console.WriteLine("厨师做好了。");
    }
}
//灶台工具类
static class CookingBench
{
    //静态工具方法:起火
    public static void Fire()
    {
        Console.WriteLine("灶台生火。");
    }
}
//服务员
class Waiter
{
    //上菜方法
    public void Serve()
    {
        Console.WriteLine("请享用。");
    }
}

在主方法中调用：

Cook cook=new Cook();
Waiter waiter=new Waiter();
​
cook.Prepare();
CookingBench.Fire();
cook.Cooking();
waiter.Serve();

    面向对象有三大特征：封装，继承，多态。下面详细讲一下：

    封装：

    每个人都有自己的秘密，在面向对象的代码中也是如此，对象中，有可以被外界查看的，也有不对外界查看的，这种将一些成员隐藏起来的思想就是封装，实现封装，需要先了解一下四个访问修饰符：public, private, protect, internal

    访问修饰符可以修饰类，属性，方法，使用修饰符修饰类或属性、方法，具有不同的访问级别。声明时访问修饰符要写在最前：

public class publicClass{}//声明一个类
private bool isPublic;//声明一个属性

    public：公共的，这个访问级别最低。

    private：私有的，故名思义，这个访问级别最高，只能在声明的作用域内访问。
    protect：受保护的，只能在继承链上被访问，说白了只有继承了一个类，才能访问这个类中protect修饰的成员。

    internal：内部的，只能在同一个程序集中访问。可以狭义的理解为同一个命名空间下可以访问。

    还有一个组合拳：protect internal，这就是既要满足同一个程序集，又得是继承的关系才能访问。

    通过这几个关键字，我们就可以实现封装。开发的时候只需要明确写的类或者属性，方法等分配什么样的访问权限即可。

    继承：

    继承的概念，也很容易理解，它就好比现实生活中，孩子继承父母的家产，那么父母的东西就成了孩子的，在C#中，类和类之间实现继承是通过":"来实现的。

public class Father{}
public class Chlid:Father{}//Child类继承了Father

    注意，C#是单继承的语言，也就是说一个类只能继承一个父类。

    子类可以继承父类中非private的属性或方法，如果private的属性或方法能访问，也就不会有protect这个关键字存在。通过继承，我们可以将子类共有的重复代码抽离到父类中，这样所有的子类就不必声明这些成员，就减少了很多代码量。在C#的继承结构中，object类是所有类的父类，任何一个类都是默认继承object。object类为我们提供了一些类中最最基础的成员，如我们常用的tostring()方法。

    面向对象中有个原则叫开闭原则，这个原则规定对修改封闭，对扩展开放，也就是说，当写了一个类并使用了一段时间后，因为项目升级或者其它原因，我们需要修改这个类（添加一些新东西），这时，根据开闭原则，我们就不能直接修改，而是要再写一个类，去继承它，在子类中添加新的业务逻辑，这也是继承的一个用途。

   继承中，还有一个概念叫做方法的重写，就是说，子类中有一个方法和继承父类的方法名一样，这样子类方法就把父类方法给覆盖了，这个过程就是重写。这个概念在具体介绍类和方法的小节中会详细展开。

    多态：

    多态依赖继承，有继承才能实现多态。同一个类，有不同的形态就是多态。比如狗这种动物，有不同的形态：哈士奇，田园犬，柯基等。在代码中的体现就是父类可以接收子类为其赋值。还是拿上面的例子来说，以下代码就是多态例子：

Father f=new Chlid();

    多态性的依据是里氏转换原则：子类继承父类，那么，原来适用于父类的场景，一定适用于子类，因为子类继承了父类的所有显式功能，父类能做的，子类也能做。这一原则就是定义这个理论的存在，子类可以直接替代父类，将父类全部转换为子类，程序的行为没有区别。

    多态性也面向对象编程中很重要的基石，我们一般在编程中尽可能地使用接口，面向抽象，降低耦合，因为多态性，我们才能通过接口或一些抽象的数据结构来实现实例的操作。

    最后通过一个例子演示一下多态（涉及到类和方法的一些知识会在下节类和方法中详解）：

public class Dog
{
    public string name { get; set; }
    
    public Dog(string name)
    {
        this.name = name;
    }
    
    public void introduce()
    {
        Console.WriteLine("这是一只：" + name);
    }
}
​
public class Husky : Dog
{
    //调用父类的构造方法，为name赋值
    public Husky():base("Husky"){}
}
​
public class Koji : Dog
{
      public Koji() : base("Koji"){}
}
​
class DogStore
{
    public Dog dog { get; set; }
​
    public DogStore(Dog dog)
    {
        this.dog = dog;
    }
​
    public void wantBuy()
    {
        Console.WriteLine("Do u want this "+dog.name+"?");
    }
}

    以上代码中有一个共同的Dog类，分别有两个类哈士奇，柯基继承了它。还有一个宠物狗商店，需要Dog这个属性。

    下面看一下主方法中的代码：

DogStore dogStore=new DogStore(new Husky());
dogStore.wantBuy();
dogStore=new DogStore(new Koji());
dogStore.wantBuy();

 

   我们通过父类，接收更加具体的子类，这就是多态性很好的体现，这也是很优雅高效的编程方式。

　个人公众号，热爱分享，知识无价。