C# 一个完整的面向对象类的三大特性示例：封装 继承 多态

以下是C#中类的封装、继承和多态的示例，

封装通过私有字段和公共方法来实现对数据的访问控制。

继承通过派生类Student继承自Person类，获得了Person类的所有属性和方法，并在此基础上扩展了自己的属性和方法。

多态通过Animal类和其子类Dog和Cat的MakeSound方法展示了同一段代码在不同对象上表现出不同的行为。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp4
{
    //封装（Encapsulation）示例：
    public class Person
    {
        private string name;  // 私有字段，只能在类内部访问
        private int age;

        public string GetName()
        {
            return name;
        }

        public void SetName(string value)
        {
            name = value;
        }

        // 其他的getter和setter方法可以类似地定义

        public void Speak()
        {
            Console.WriteLine("My name is " + name);
        }
    }
    //继承（Inheritance）示例：
    public class Student : Person  // Student类继承自Person类
    {
        private string school;

        public string GetSchool()
        {
            return school;
        }

        public void SetSchool(string value)
        {
            school = value;
        }

        public void Study()
        {
            Console.WriteLine("I am studying at " + school);
        }
    }

    #region  多态（Polymorphism）示例：
    public class Animal
    {
        public virtual void MakeSound()  // 使用virtual关键字声明可重写的方法
        {
            Console.WriteLine("The animal makes a sound");
        }
    }

    public class Dog : Animal
    {
        public override void MakeSound()  // 使用override关键字重写基类的方法
        {
            Console.WriteLine("The dog barks");
        }
    }

    public class Cat : Animal
    {
        public override void MakeSound()
        {
            Console.WriteLine("The cat meows");
        }
    }


    #endregion

    internal class Program
    {
        static void Main(string[] args)
        {
            Person person = new Person();
            person.SetName("John");
            person.Speak();  // 输出：My name is John

            Student student = new Student();
            student.SetName("Tom");
            student.SetSchool("ABC School");
            student.Speak();  // 输出：My name is Tom
            student.Study();  // 输出：I am studying at ABC School

            Animal animal = new Animal();
            Dog dog = new Dog();
            Cat cat = new Cat();

            animal.MakeSound();  // 输出：The animal makes a sound
            dog.MakeSound();  // 输出：The dog barks
            cat.MakeSound();  // 输出：The cat meows

            Animal anotherAnimal = new Dog();
            anotherAnimal.MakeSound();  // 输出：The dog barks
            Console.ReadKey();
        }
    }
}

封装是面向对象的核心概念之一，它通过将数据和方法组合成一个实体（类），并将其对外部隐藏，以实现对数据的保护和控制访问的方式。在C#中，可以使用访问修饰符（如public、private、protected等）来控制类成员的访问级别，以实现封装。

继承是一种面向对象的机制，它允许一个类继承另一个类的属性和方法。在C#中，使用关键字class来定义一个类，使用冒号:来指定基类。子类（派生类）会继承基类（父类）的属性和方法，并可以在此基础上添加新的属性和方法，以实现代码的重用和扩展。

多态是一种面向对象的特性，它允许使用父类的引用指向子类的对象，并根据不同的对象调用相同的方法时，执行相应的实现。在C#中，可以通过继承和重写基类的方法来实现多态。通过多态，可以提高代码的灵活性和重用性，使程序更加易于扩展和维护。

总结：

• 封装将数据和方法组合成一个实体，并对外部隐藏细节；
• 继承允许一个类继承另一个类的属性和方法，实现代码的重用和扩展；
• 多态允许使用父类的引用指向子类的对象，并根据对象调用相同方法时，执行相应的实现。