面向对象(OOP)，封装，继承，多态，抽象方法，重写，重载，覆写，虚方法，OOP

Sx_Oracle

已于 2024-03-29 14:41:12 修改

阅读量533

点赞数 12

文章标签： c# asp.net .netcore .net 设计规范

于 2024-03-29 14:38:45 首次发布

本文链接：https://blog.csdn.net/sx_oracle/article/details/137144745

版权

C#_面向对象(OOP)

文章目录

- C#_面向对象(OOP)

C#面向对象的延伸主要源于软件开发的实际需求和对代码结构优化的追求。面向对象编程（OOP）是一种软件开发方法，它将现实世界的事物抽象为对象，通过对象之间的交互来实现软件功能。这种方法更符合人类的思维习惯，使得代码更加易于理解和维护。

C#作为微软推出的一种现代编程语言，自然继承了OOP的核心思想，并将其作为语言的基础特性之一。通过面向对象的方式，C#能够提供更强大的代码组织、重用和扩展能力，使得开发者能够更高效地构建复杂的软件系统。

面向对象的优点主要有以下几点：

代码重用性高：通过继承和组合等机制，可以方便地重用已有的代码，提高开发效率。
可维护性强：将数据和操作封装在对象中，降低了模块之间的耦合度，使得代码更易于修改和维护。
灵活性高：多态性使得程序能够更灵活地应对变化，提高了系统的可扩展性。

然而，面向对象编程也存在一些缺点：

设计复杂度增加：面向对象的设计需要考虑类、对象、继承、封装、多态等多个方面，增加了设计的复杂度。
性能损耗：由于需要维护对象之间的关系和进行动态绑定等操作，可能会带来一定的性能损耗。
学习曲线陡峭：对于初学者来说，理解和掌握面向对象的思想和技巧需要一定的时间和经验。

综上所述，C#延伸出面向对象编程是为了更好地满足软件开发的实际需求，提高代码的质量和效率。虽然面向对象编程存在一些缺点，但其优点远大于缺点，因此在现代软件开发中得到了广泛的应用。

1. 封装（Encapsulation）

优点：

隐藏对象的内部状态和实现细节，只暴露必要的接口给外部使用。
提高代码的安全性和可维护性。
简化对象的使用方式。

缺点：

过度封装可能导致代码难以理解和维护。
封装可能导致一些性能损失，因为每次访问内部状态都需要通过方法或属性。

**注：**封装是隐藏对象的属性和实现细节，仅对外提供公共访问方式的过程。封装提高了代码的安全性和可维护性。
代码示例

// 封装示例：Person类封装了年龄属性  
public class Person  
{  
    // 私有字段，外界不能直接访问  
    private int age;  
  
    // 公共属性，提供对age字段的访问  
    public int Age  
    {  
        get { return age; }  
        set { age = (value >= 0) ? value : throw new ArgumentOutOfRangeException(nameof(value), "Age cannot be negative."); }  
    }  
  
    // 构造方法  
    public Person(int age)  
    {  
        this.Age = age;  
    }  
}

程序调用

using System;  
  
class Program  
{  
    static void Main(string[] args)  
    {  
        try  
        {  
            // 创建Person对象并设置年龄为25（合法值）  
            Person person = new Person(25);  
  
            // 访问Age属性以获取年龄  
            Console.WriteLine("Person's age: " + person.Age); // 输出：Person's age: 25  
  
            // 尝试设置年龄为-1（非法值），这将引发异常  
            person.Age = -1; // 这里会抛出ArgumentOutOfRangeException  
        }  
        catch (ArgumentOutOfRangeException ex)  
        {  
            // 处理异常  
            Console.WriteLine("Error: " + ex.Message); // 输出：Error: Age cannot be negative.  
        }  
  
        // 尝试再次设置年龄为30（合法值）  
        try  
        {  
            Person anotherPerson = new Person(30);  
            Console.WriteLine("Another person's age: " + anotherPerson.Age); // 输出：Another person's age: 30  
        }  
        catch (Exception ex)  
        {  
            // 这里不应该捕获到任何异常，因为年龄是合法的  
            Console.WriteLine("Unexpected error: " + ex.Message);  
        }  
    }  
}

2. 继承（Inheritance）

优点：

实现代码的重用，减少重复代码。
支持类的层次结构，便于管理和组织代码。
使得子类可以扩展父类的功能。

缺点：

继承可能导致类之间的耦合度过高，不利于代码的灵活性和可维护性。
破坏封装性，子类可以访问父类的受保护（protected）和私有（private）成员。

**注：**继承允许我们创建一个新的类（派生类），继承自一个已有的类（基类），从而复用基类的代码。
代码示例：

// 继承示例：Student类继承自Person类  
public class Student : Person  
{  
    // 新增属性  
    public string StudentId { get; set; }  
  
    // 构造方法  
    public Student(int age, string studentId) : base(age)  
    {  
        this.StudentId = studentId;  
    }

3. 多态（Polymorphism）

优点：

提高代码的灵活性和可扩展性。
允许使用统一的接口来处理不同类型的对象。
降低代码之间的耦合度。

缺点：

多态可能增加代码的复杂性，需要仔细设计和管理类之间的关系。
在某些情况下，多态可能导致性能下降。

**注：**多态意味着同一操作作用于不同的对象，可以有不同的解释和执行结果。多态性通过虚方法、抽象方法和接口实现。

代码示例：

// 多态示例：通过重写虚方法实现多态  
public class Animal  
{  
    public virtual void MakeSound()  
    {  
        Console.WriteLine("The animal makes a sound");  
    }  
}  
  
public class Dog : Animal  
{  
    public override void MakeSound()  
    {  
        Console.WriteLine("The dog barks");  
    }  
}  
  
public class Cat : Animal  
{  
    public override void MakeSound()  
    {  
        Console.WriteLine("The cat meows");  
    }  
}  
  
// 使用示例  
Animal animal1 = new Dog();  
Animal animal2 = new Cat();  
animal1.MakeSound(); // 输出 "The dog barks"  
animal2.MakeSound(); // 输出 "The cat meows"

重写（Override）与覆写

**注：**重写（Override）是子类对父类中虚方法（Virtual Method）或抽象方法（Abstract Method）的重新实现。覆写实际上是重写的另一种说法，在C#中两者含义相同。

public class Animal  
{  
    public virtual void MakeSound() // 虚方法  
    {  
        Console.WriteLine("The animal makes a sound");  
    }  
}  
  
public class Dog : Animal  
{  
    public override void MakeSound() // 重写父类的虚方法  
    {  
        Console.WriteLine("The dog barks");  
    }  
}

重载（Overload）

**注：**重载（Overload）是在同一个类中定义多个同名但参数列表不同的方法。

public class Calculator  
{  
    public int Add(int a, int b) // 重载Add方法，接收两个整数参数  
    {  
        return a + b;  
    }  
  
    public double Add(double a, double b) // 重载Add方法，接收两个浮点数参数  
    {  
        return a + b;  
    }  
}

抽象方法（Abstract Method）与虚方法（Virtual Method）

抽象方法：

定义在抽象类中，只有声明没有实现。
子类必须实现抽象方法。

虚方法：

定义在普通类中，有默认实现。
子类可以选择是否重写虚方法。

public abstract class Animal // 抽象类  
{  
    public abstract void MakeSound(); // 抽象方法，没有实现  
}  
  
public class Dog : Animal // 子类实现抽象方法  
{  
    public override void MakeSound() // 重写抽象方法  
    {  
        Console.WriteLine("The dog barks");  
    }  
}  
  
public class Vehicle // 含有虚方法的类  
{  
    public virtual void Start() // 虚方法，有默认实现  
    {  
        Console.WriteLine("The vehicle starts");  
    }  
}  
  
public class Car : Vehicle // 子类重写虚方法  
{  
    public override void Start() // 重写父类的虚方法  
    {  
        Console.WriteLine("The car starts with a purr");  
    }  
}