C# 面向对象编程的三大支柱：封装、继承与多态

新腾讯网友

面向对象编程（OOP）是一种广泛使用的编程范式，它通过封装、继承和多态这三大支柱来构建灵活且可维护的代码结构。本文将详细介绍这三大支柱在C#语言中的应用，并通过示例代码展示它们的具体实现。
一、封装（Encapsulation）

封装是指将对象的属性（字段）和行为（方法）结合在一起，并对外部隐藏对象的具体实现细节，仅暴露必要的接口供外部使用。封装提高了代码的安全性和可维护性。
示例代码

1. using System;
   
2. 
   
3. namespace EncapsulationExample
   
4. {
   
5.     class Person
   
6.     {
   
7.         // 私有字段
   
8.         private string name;
   
9.         private int age;
   
10. 
    
11.         // 公共属性，通过get和set访问器控制字段的访问
    
12.         public string Name
    
13.         {
    
14.             get { return name; }
    
15.             set { name = value; }
    
16.         }
    
17. 
    
18.         public int Age
    
19.         {
    
20.             get { return age; }
    
21.             set
    
22.             {
    
23.                 // 添加逻辑校验，例如年龄应为非负数
    
24.                 if (value >= 0)
    
25.                     age = value;
    
26.                 else
    
27.                     throw new ArgumentException("Age must be non-negative.");
    
28.             }
    
29.         }
    
30. 
    
31.         // 方法
    
32.         public void DisplayInfo()
    
33.         {
    
34.             Console.WriteLine($"Name: {name}, Age: {age}");
    
35.         }
    
36.     }
    
37. 
    
38.     class Program
    
39.     {
    
40.         static void Main(string[] args)
    
41.         {
    
42.             Person person = new Person();
    
43.             person.Name = "Alice";
    
44.             person.Age = 30;
    
45.             person.DisplayInfo();
    
46. 
    
47.             // 尝试设置非法年龄会抛出异常
    
48.             try
    
49.             {
    
50.                 person.Age = -5;
    
51.             }
    
52.             catch (ArgumentException ex)
    
53.             {
    
54.                 Console.WriteLine(ex.Message);
    
55.             }
    
56.         }
    
57.     }
    
58. }

复制代码

二、继承（Inheritance）

继承允许一个类（子类）继承另一个类（父类）的属性和方法，从而实现代码的重用和扩展。子类可以新增或重写父类的方法，但必须遵守父类定义的接口契约。
示例代码

1. using System;
   
2. 
   
3. namespace InheritanceExample
   
4. {
   
5.     // 父类
   
6.     class Animal
   
7.     {
   
8.         public void Eat()
   
9.         {
   
10.             Console.WriteLine("Eating...");
    
11.         }
    
12.     }
    
13. 
    
14.     // 子类
    
15.     class Dog : Animal
    
16.     {
    
17.         // 新增方法
    
18.         public void Bark()
    
19.         {
    
20.             Console.WriteLine("Barking...");
    
21.         }
    
22. 
    
23.         // 重写父类方法
    
24.         public new void Eat()
    
25.         {
    
26.             Console.WriteLine("Dog is eating specific food...");
    
27.         }
    
28.     }
    
29. 
    
30.     class Program
    
31.     {
    
32.         static void Main(string[] args)
    
33.         {
    
34.             Dog dog = new Dog();
    
35.             dog.Eat();  // 调用子类的方法
    
36.             dog.Bark();
    
37.         }
    
38.     }
    
39. }

复制代码

三、多态（Polymorphism）

多态是指允许使用对象的某个基类引用来指向其任何派生类的对象，并通过这个基类引用调用派生类中重写的方法。多态性使得代码更加灵活和可扩展。
示例代码

1. using System;
   
2. 
   
3. namespace PolymorphismExample
   
4. {
   
5.     // 抽象父类
   
6.     abstract class Shape
   
7.     {
   
8.         // 抽象方法
   
9.         public abstract double GetArea();
   
10.     }
    
11. 
    
12.     // 子类：圆形
    
13.     class Circle : Shape
    
14.     {
    
15.         public double Radius { get; set; }
    
16. 
    
17.         public override double GetArea()
    
18.         {
    
19.             return Math.PI * Radius * Radius;
    
20.         }
    
21.     }
    
22. 
    
23.     // 子类：矩形
    
24.     class Rectangle : Shape
    
25.     {
    
26.         public double Width { get; set; }
    
27.         public double Height { get; set; }
    
28. 
    
29.         public override double GetArea()
    
30.         {
    
31.             return Width * Height;
    
32.         }
    
33.     }
    
34. 
    
35.     class Program
    
36.     {
    
37.         static void Main(string[] args)
    
38.         {
    
39.             // 多态性：使用基类引用来指向派生类对象
    
40.             Shape circle = new Circle { Radius = 5 };
    
41.             Shape rectangle = new Rectangle { Width = 4, Height = 6 };
    
42. 
    
43.             Console.WriteLine($"Circle Area: {circle.GetArea()}");
    
44.             Console.WriteLine($"Rectangle Area: {rectangle.GetArea()}");
    
45.         }
    
46.     }
    
47. }

复制代码

总结

封装、继承和多态是面向对象编程的三大基本支柱，它们在C#中得到了充分的支持。通过封装，我们可以保护对象的内部状态；通过继承，我们可以重用和扩展现有的代码；通过多态，我们可以编写更加灵活和可扩展的代码。理解和掌握这三大支柱，对于编写高质量的C#程序至关重要。希望本文的示例代码能够帮助读者更好地理解和应用这些概念。

来源:https://www.cnblogs.com/lyl6796910/p/18418833
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！