面向过程 VS 面向对象

面向过程

• 以 过程 为中心 的编程思想，在编程时把 解决问题的 步骤 分解出来，使用函数实现这些步骤，再一步步按顺序调用函数，直至解决问题
• 按照面向过程的思想，在解决问题时，各函数之间是为了问题服务
• 面向过程思想偏向于我们做一件事的流程，首先做什么，其次做什么，最后做什么

特性

自顶向下、逐步求精、模块化

image.png

面向对象

• 以 对象 为中心的编程思想，在编程时把要 解决的问题 抽象成 各个对象
• 建立对象的目的 不是为了完成一个步骤，而是为了描叙某个对象在整个解决问题的步骤中的属性和行为
• 按照面向对象的思想，是站在提出问题的主体的角度去解决问题，可将解决这一具体问题的步骤，抽象为解决这一类问题的方法，以后再遇到类似的问题，可以复用解决思路
• 面向对象是按人们认识客观世界的系统思维方式，采用基于对象（实体）的概念建立模型，模拟客观世界分析、设计、实现软件的方法
• 通过面向对象的理念，将计算机软件系统能与现实世界中的系统一一对应

特性

封装、继承、多态、抽象

image.png

举例

需求： 写一道 蛋炒饭 的程序

蛋炒饭 和 盖浇饭

蛋炒饭： 有一道工序是把 鸡蛋和 米饭混合一起炒
盖浇饭： 点什么菜，最后就把 这道菜 和 米饭混合一起炒

如果用 面向过程 的思想，写出了程序最后就是 一份 具体 的蛋炒饭
如果用 面向对象 的思想，可以根据 需要 写出 需要的 炒饭，可以是 蛋炒饭/红烧肉盖饭/青椒土豆盖浇饭

根据 面向过程的思想，就是只 做一道 蛋炒饭 的程序
根据 面向对象的思想，把 菜 和 饭 作为 对象 抽离 出来，根据需求 输入 相应 的菜 和饭，就能得到 对应 的 炒饭程序

面向对象编程的特征

面向对象编程的四项基本原则为：

• 抽象：抽象是简化复杂系统的过程，将实体的相关特性和交互建模为类，以定义系统的抽象表示。抽象通过抽象类和接口来实现，抽象类定义了一些具体和一些抽象的方法，而接口定义了一组方法的契约，由实现类提供具体实现
• 封装： 封装是将对象的状态（数据）和行为（方法）捆绑在一起，隐藏对象的内部状态和功能，通过使用访问修饰符，控制允许通过一组公共成员/函数进行访问
• 继承：继承是一种机制，允许一个类（派生类）使用另一个类（基类）的属性和方法，同时继承也支持创建类的层次结构，通过在派生类中添加、修改或隐藏成员，实现对基类的扩展
• 多态： 多态是一种通过同一接口（方法名）来表示不同实现的机制，多态通常通过方法的重写（override）和接口实现来实现

抽象

• 抽象是通过隐藏不必要的细节，突出重点的特征，将实体抽象为类。
• 抽象出来的类可以使用 abstract 关键字 来定义类

将计算图形面积 的共性 抽象成 类 Shape，使用具体实现类实现面积计算

// 抽象类
public abstract class Shape
{
    // 抽象方法，用于计算图形的面积
    public abstract double CalculateArea();
}
// Circle 是 具体的实现类 
public class Circle : Shape
{
    // 圆形的半径
    public double Radius { get; set; }

    // 实现 CalculateArea 方法： 计算圆型的面积
    public override double CalculateArea()
    {
        return Math.PI * Radius * Radius;
    }
}
// Rectangle 是 具体的实现类 
public class Rectangle : Shape
{
    // 矩形的长和宽
    public double Length { get; set; }
    public double Width { get; set; }

    // 实现 CalculateArea 方法： 计算矩形的面积
    public override double CalculateArea()
    {
        return Length * Width;
    }
}

封装

• 封装是将数据和方法封装在同一个单元中
• 通过定义公共接口（公共方法）来控制对数据的访问
• 封装是为了防止外部直接访问数据，防止内部数据被随意的定义和修改，保障数据的安全性

image.png

public class Person
{
    // 封装的字段，私有字段只能在类内部访问
    private string name;
    private int age;

    // 封装的属性，提供对私有字段的访问和修改
    public string Name
    {
        get { return name; }
        set { name = value; }
    }

    public int Age
    {
        get { return age; }
        set
        {
            // 对年龄进行一些验证
            if (value >= 0 && value <= 120)
            {
                age = value;
            }
            else
            {
                Console.WriteLine("Invalid age value");
            }
        }
    }

    // 公共方法，对外提供访问和操作封装字段的接口
    public void DisplayInfo()
    {
        Console.WriteLine($"Name: {Name}, Age: {Age}");
    }
}

class Program
{
    static void Main()
    {
        // 创建 Person 对象
        Person person1 = new Person();

        // 设置对象的属性值
        person1.Name = "John";
        // 设置 Age 的值， 但是 外界对于 Age 的一些验证并不知情
        person1.Age = 25;

        // 调用方法显示信息
        person1.DisplayInfo();
    }
}

继承

• 基于某一个类进行扩展，使一个新类直接拥有基类的基本特征，而不需要重复去写，这就是继承的思想
• C# 中，类只能继承一个类，一个子类只能有一个父类，一个父类可以有多个子类，若要实现多重继承，可以采用接口的形式
• 在 C# 中，类默认继承自 System.Object 类,直接继承的是直接父类，即使没有显式指定某个类的基类，它仍然隐式地继承自 System.Object
• C#中，使用 class 关键字来定义一个类，使用 :(冒号) 来表示继承关系

class Animal
{
    public void Eat()
    {
        Console.WriteLine("Animal is eating");
    }
}
// Mammal 类继承 Animal
class Mammal : Animal
{
    public void Sleep()
    {
        Console.WriteLine("Mammal is sleeping");
    }
}
// Dog 的直接父类是 Mammal，间接父类  Animal
class Dog : Mammal
{
    public void Bark()
    {
        Console.WriteLine("Dog is barking");
    }
}

多态

• 多态是一种通过同一接口（方法名）来表示不同实现的机制
• 多态性有两种主要形式：编译时多态性和运行时多态性
• 编译时多态性（静态多态性）是编译时，通常与方法的重载（overloading）有关，同一个类中有多个方法具有相同的名称但不同的参数列表
• 运行时多态性（动态多态性）是运行时，通常与方法的重写（overriding）有关，子类可以提供对基类方法的新实现

class Animal
{
    public virtual void MakeSound()
    {
        Console.WriteLine("Generic animal sound");
    }
}

class Dog : Animal
{
    // 重写
    public override void MakeSound()
    {
        Console.WriteLine("Woof! Woof!");
    }

    public void Gender(int x)
    {
        if(x==1)
         {
          Console.WriteLine("Gender: 男");
         }
         else if (x==2)
         {
           Console.WriteLine("Gender: 女");
         }
         else
         {
         Console.WriteLine("Gender: 不明确");
         }
    }
    // 重载
    public void Gender(string s)
    {
        Console.WriteLine("Gender： " + s);
    }

}

class Cat : Animal
{
    public override void MakeSound()
    {
        Console.WriteLine("Meow!");
    }
}

class Program
{
    static void Main()
    {
        Animal animal = new Dog();
        animal.MakeSound();  // 运行时确定调用 Dog 类中的 MakeSound 方法
        animal.Gender(1);   // 编译时确定调用 Dog 类中的 Gender(int x)方法
        animal.Gender("男")  // 编译时确定调用 Dog 类中的 Gender(string x)方法
        animal = new Cat();
        animal.MakeSound();  // 运行时确定调用 Cat 类中的 MakeSound 方法
    }
}

方法的重载

方法的重载是指在同一个类中，可以定义多个具有相同名称但参数列表不同的方法

• 重载的方法具有相同的方法名
• 参数列表必须不同，包括参数的类型、个数或顺序
• 返回类型可以相同也可以不同

class Calculator
{
    public int Add(int a, int b)
    {
        return a + b;
    }

    public double Add(double a, double b)
    {
        return a + b;
    }

    public string Add(string a, string b)
    {
        return a + b;
    }
}

方法的重写

方法的重写是指在派生类中重新实现（覆盖）基类中已有的方法

• 重写的方法具有相同的方法签名（方法名、参数列表、返回类型），并且在基类中必须是虚拟（virtual）或抽象（abstract）的
• 使用 override 关键字进行重写

class Shape
{
    public virtual void Draw()
    {
        Console.WriteLine("Drawing a shape");
    }
}

class Circle : Shape
{
    public override void Draw()
    {
        Console.WriteLine("Drawing a circle");
    }
}

重写和重载的区别

方法名称

重载：方法名相同，参数列表不同
重写：方法名相同，参数列表相同

发生位置

重载：在同一个类中
重写：在派生类中

关键字

重载：使用相同的方法名，不需要额外的关键字
重写：使用 override 关键字

调用方式

重载：编译器根据调用时的参数类型、个数、顺序选择合适的方法
重写：运行时根据对象的实际类型选择调用的方法

用途

重载：提供更灵活的方法调用，可以根据不同的参数执行不同的逻辑
重写：实现多态，允许派生类提供特定于其类型的实现