C#基础篇（05）面向对象编程的三大特性（封装、继承、多态）

一、封装

封装是面向对象编程的三大特性之一（封装、继承、多态），它是指将数据（属性）和行为（方法）组合在一个类中，并对外部隐藏对象的内部实现细节。

1. 封装的核心概念

• ​数据隐藏​：将类的内部数据设为私有，只通过公共方法访问
• ​实现隐藏​：隐藏类的内部实现细节，只暴露必要的接口
• ​保护数据完整性​：通过方法控制对数据的访问和修改

2. 属性的封装

public class Person
{
    private string _name; // 私有字段
    private int _age;
    
    // 公共属性
    public string Name
    {
        get { return _name; }
        set 
        { 
            if (!string.IsNullOrEmpty(value))
                _name = value; 
        }
    }
    
    public int Age
    {
        get { return _age; }
        set 
        {
            if (value >= 0 && value <= 120)
                _age = value;
            else
                throw new ArgumentOutOfRangeException("年龄必须在0-120之间");
        }
    }
}

3. 方法的封装

public class Person
{
    private string _name; // 私有字段
    private int _age;
    
    // 公共属性
    public string Name
    {
        get { return _name; }
        set 
        { 
            if (!string.IsNullOrEmpty(value))
                _name = value; 
        }
    }
    
    public int Age
    {
        get { return _age; }
        set 
        {
            if (value >= 0 && value <= 120)
                _age = value;
            else
                throw new ArgumentOutOfRangeException("年龄必须在0-120之间");
        }
    }

    // 方法
    public void eat()
    {
        Console.WriteLine("eat");
    }
}

4. 封装的好处

1. ​数据保护​：防止外部代码直接修改对象内部状态
2. ​灵活性​：可以修改内部实现而不影响使用该类的代码
3. ​易于维护​：将相关数据和操作组织在一起
4. ​减少耦合​：类之间通过明确定义的接口交互
5. ​数据验证​：可以在设置属性时添加验证逻辑

二、继承

继承是面向对象编程的三大特性之一（封装、继承、多态），它允许我们基于现有类创建新类，实现代码重用和层次结构设计。

1. 继承的特点

• ​单继承​：C# 只支持单继承，一个类只能直接继承一个父类
• ​传递性​：继承关系可以多层传递
• ​所有类都继承自 Object​：即使没有显式指定，所有类都隐式继承自 System.Objec

2. 继承中的访问修饰符

• public：任何代码都可访问
• protected：只有类内部和派生类可访问
• private：只有类内部可访问（默认）
• internal：同一程序集内可访问
• protected internal：同一程序集或派生类可访问

3. 继承的基本语法

public class Animal  // 基类
{
    public string Name { get; set; }
    
    public void Eat()
    {
        Console.WriteLine($"{Name}正在吃东西");
    }
}

public class Dog : Animal  // 派生类
{
    public void Bark()
    {
        Console.WriteLine($"{Name}在汪汪叫");
    }
}

// 使用示例
Dog myDog = new Dog();
myDog.Name = "旺财";
myDog.Eat();  // 继承自Animal类的方法
myDog.Bark(); // Dog类自己的方法

4. 子类的继承函数

class Animal
{
    public string Name;

    public Animal()
    {
        Console.WriteLine("Animal的无参构造");
    }
    public Animal(string name)
    {
        Name = name;
        Console.WriteLine("Animal的有参构造");
    }
}

class Dog : Animal
{
    public string Age;
    public Dog()
    {
        Console.WriteLine("Dog的无参构造");
    }
    public Dog(string age)
    {
        Age = age;
        Console.WriteLine("Dog的有参构造");
    }
}

（1）当调用子类的无参构造函数时，会先调用的父类的无参构造函数。

Dog dog = new Dog();    
// 输出：
// Animal的无参构造
// Dog的无参构造

（2）如果想调用有参的构造函数，但只能给子类的特有参数赋值。

Dog dog = new Dog("5");    
// 输出：
// Animal的无参构造
// Dog的有参构造

（3）如果想同时给子类特有的和父类的属性赋值，则需要改写子类的有参构造函数。

class Dog : Animal
{
    public string Age;
    public Dog()
    {
        Console.WriteLine("Dog的无参构造");
    }
    public Dog(string age, string name) : base(name)
    {
        Age = age;
        Console.WriteLine("Dog的有参构造");
    }
}

Dog dog = new Dog("12", "旺财");
// 输出：
// Animal的有参构造
// Dog的有参构造

三、多态

多态是面向对象编程的三大特性之一（封装、继承、多态），它允许不同类的对象对同一消息做出不同的响应。在C#中，多态主要通过以下几种方式实现：

1. 方法重载 Overloading（静态多态）

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

2. 方法重写 Overriding（动态多态）

（1）通过virtual和override关键字实现：

public class Shape
{
    public virtual void Draw()
    {
        Console.WriteLine("绘制一个形状");
    }
}

public class Circle : Shape
{
    public override void Draw()
    {
        Console.WriteLine("绘制一个圆形");
    }
}

（2）通过new关键字实现：

public class Shape
{
    public void Draw()
    {
        Console.WriteLine("绘制一个形状");
    }
}

public class Circle : Shape
{
    public new void Draw()
    {
        Console.WriteLine("绘制一个圆形");
    }
}