C# 面向对象三大特性：封装、继承、多态

C# 面向对象三大特性是封装、继承和多态。这三个特性是面向对象编程最基本、最重要的概念。在本篇攻略中，我们将详细讲解它们的含义，以及如何在C#中使用它们。

封装

封装是指将对象的属性和方法封装在一起，形成一个类。类可以通过统一的接口来控制属性和方法的访问。在C#中，可以通过属性和方法的访问修饰符来实现封装。

属性封装示例：

class Person
{
    private string name;

    public string Name 
    {
        get { return name; } 
        set { name = value; }
    }
}

Person p = new Person();
p.Name = "张三";  // 调用set方法对属性进行赋值
string name = p.Name; // 调用get方法获取属性值

以上示例中，Person类的name字段被封装在了Name属性中。外部不能直接访问name字段，必须通过Name属性来访问。 set方法用于为属性赋值，get方法用于获取属性的值。

方法封装示例：

class Person
{
    private string name;

    public void SetName(string name)
    {
        this.name = name;
    }

    public string GetName()
    {
        return name;
    }
}

Person p = new Person();
p.SetName("张三"); // 调用SetName方法为name字段赋值
string name = p.GetName(); // 调用GetName方法获取name的值

以上示例中，Person类的name字段被封装在SetName和GetName方法中。外部不能直接访问name字段，必须通过调用SetName和GetName方法来访问。 SetName方法用于为name字段赋值，GetName方法用于获取name的值。

继承

继承是指从已有的类中继承出新的类，新的类拥有原始类的全部特性，并且可以在此基础上添加新的属性和方法。继承允许我们在不破坏原有系统的基础上，扩展原有系统的功能。

以下是继承的示例：

class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
}

class Employee : Person
{
    public double Salary { get; set; }
}

Employee emp = new Employee();
emp.Name = "张三";
emp.Age = 24;
emp.Salary = 5000;

以上示例中，Employee类继承自Person类，拥有Name和Age属性。此外，Employee类还有一个自己的Salary属性。

多态

多态是指一个对象可以有多种不同的类型。在C#中，多态可以实现为函数重载、虚函数和抽象类。

以下是多态的示例：

函数重载多态示例：

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

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

Math math = new Math();
int result1 = math.Add(2, 3);  // 调用int类型的Add方法
double result2 = math.Add(2.1, 3.2); // 调用double类型的Add方法

以上示例中，Math类中定义了两个Add方法，一个参数类型为int，另一个参数类型为double，实现了函数重载，可以根据传入参数类型的不同自动调用不同的方法。

虚函数多态示例：

class Animal
{
    public virtual void SayHello()
    {
        Console.WriteLine("我是一只动物");
    }
}

class Cat : Animal
{
    public override void SayHello()
    {
        Console.WriteLine("我是一只猫咪");
    }
}

class Dog : Animal
{
    public override void SayHello()
    {
        Console.WriteLine("我是一只狗狗");
    }
}

Animal animal1 = new Animal();
Animal animal2 = new Cat();
Animal animal3 = new Dog();
animal1.SayHello(); // 输出：“我是一只动物”
animal2.SayHello(); // 输出：“我是一只猫咪”
animal3.SayHello(); // 输出：“我是一只狗狗”

以上示例中，Animal类中定义了一个虚函数SayHello，Cat和Dog类继承自Animal类并重写了SayHello函数。通过动态绑定，可以在运行时自动调用正确的虚函数。

抽象类多态示例：

abstract class Shape
{
    public abstract double GetArea();
}

class Rectangle : Shape
{
    private double length;
    private double width;

    public Rectangle(double length, double width)
    {
        this.length = length;
        this.width = width;
    }

    public override double GetArea()
    {
        return length * width;
    }
}

class Circle : Shape
{
    private double radius;

    public Circle(double radius)
    {
        this.radius = radius;
    }

    public override double GetArea()
    {
        return Math.PI * radius * radius;
    }
}

Shape shape1 = new Rectangle(10, 20);
Shape shape2 = new Circle(5);
double area1 = shape1.GetArea(); // 返回200
double area2 = shape2.GetArea(); // 返回78.53981633974483

以上示例中，Shape类是一个抽象类，其中定义了一个抽象函数GetArea，Rectangle和Circle类继承自Shape类并重写了GetArea函数。通过引用Shape类，可以在运行时自动调用正确的GetArea函数。

总结

本篇攻略介绍了C#中的三大面向对象特性：封装、继承、多态，并通过相关的示例详细讲解了它们的含义以及应用。熟练掌握这三大特性对于编写高质量的C#代码非常重要，希望本篇攻略能够对你有所帮助。