C# 封装、继承、抽象、接口

在C#中，封装、继承、抽象、接口是面向对象编程（OOP）的四大核心特性，它们共同支撑了代码的复用性、扩展性和可维护性。下面分别详解：

一、封装（Encapsulation）

定义：将类的内部数据（字段）和操作数据的方法捆绑在一起，隐藏内部实现细节，只通过公开的接口（属性、方法）与外部交互。
核心目的：保护数据不被随意修改，确保数据的合法性；降低外部代码对类内部实现的依赖。

实现方式：通过访问修饰符控制成员的可见性：

• private：仅类内部可访问（核心数据通常设为private）；
• public：外部可直接访问（公开的接口）；
• protected：类内部及派生类可访问；
• internal：同一程序集内可访问。

示例：
通过“私有字段+公开属性”实现封装，确保年龄（_age）只能被合法赋值（非负数）：

public class Person
{
    // 私有字段：隐藏内部数据
    private int _age;

    // 公开属性：提供访问接口，附加验证逻辑
    public int Age
    {
        get { return _age; }  // 读取
        set 
        { 
            if (value >= 0)  // 验证：年龄不能为负数
                _age = value; 
            else 
                throw new ArgumentException("年龄不能为负数");
        }
    }

    // 公开方法：外部可调用的操作
    public void SayHello()
    {
        Console.WriteLine($"我今年{_age}岁");
    }
}

// 使用
var person = new Person();
person.Age = 20;  // 合法赋值
person.SayHello();  // 输出：我今年20岁
// person.Age = -5;  // 抛出异常（被封装逻辑拦截）

二、继承（Inheritance）

定义：允许一个类（派生类/子类）继承另一个类（基类/父类）的成员（字段、方法等），并可扩展或重写基类功能。
核心目的：实现代码复用（避免重复编写相同逻辑）；建立类的层次关系（如“动物→狗→金毛”）。

C#继承规则：

• 单继承：一个类只能直接继承一个基类（但可间接继承多层）；
• 基类成员访问：派生类可访问基类的public/protected成员，private成员不可访问；
• 重写：基类用virtual声明可重写方法，派生类用override重写。

示例：
基类Animal定义通用行为，派生类Dog和Cat继承并扩展：

// 基类
public class Animal
{
    public string Name { get; set; }

    // 虚方法：允许派生类重写
    public virtual void MakeSound()
    {
        Console.WriteLine("动物发出声音");
    }
}

// 派生类Dog（继承Animal）
public class Dog : Animal
{
    // 重写基类方法
    public override void MakeSound()
    {
        Console.WriteLine($"{Name}汪汪叫");
    }

    // 扩展基类：新增子类特有方法
    public void Fetch()
    {
        Console.WriteLine($"{Name}叼球");
    }
}

// 派生类Cat
public class Cat : Animal
{
    public override void MakeSound()
    {
        Console.WriteLine($"{Name}喵喵叫");
    }
}

// 使用
var dog = new Dog { Name = "旺财" };
dog.MakeSound();  // 输出：旺财汪汪叫（重写的方法）
dog.Fetch();      // 输出：旺财叼球（子类特有方法）

var cat = new Cat { Name = "咪咪" };
cat.MakeSound();  // 输出：咪咪喵喵叫

三、抽象（Abstraction）

定义：通过抽象类（abstract class）提取多个类的共同特征，定义“必须实现的行为”，但不提供具体实现。
核心目的：强制派生类遵循统一的接口；隐藏复杂逻辑的细节，只暴露必要的骨架。

抽象类特点：

• 不能实例化（无法new），只能作为基类被继承；
• 可包含抽象方法（abstract修饰，无实现体，派生类必须用override实现）；
• 可包含具体方法（有实现体，派生类可直接使用或重写）。

示例：
抽象类Shape定义“计算面积”的抽象行为，派生类Circle和Rectangle必须实现：

// 抽象类：定义共同接口
public abstract class Shape
{
    // 抽象方法：无实现，强制派生类实现
    public abstract double CalculateArea();

    // 具体方法：提供通用实现
    public void PrintArea()
    {
        Console.WriteLine($"面积：{CalculateArea()}");
    }
}

// 派生类：必须实现抽象方法
public class Circle : Shape
{
    public double Radius { get; set; }

    public override double CalculateArea()
    {
        return Math.PI * Radius * Radius;  // 圆面积公式
    }
}

public class Rectangle : Shape
{
    public double Width { get; set; }
    public double Height { get; set; }

    public override double CalculateArea()
    {
        return Width * Height;  // 矩形面积公式
    }
}

// 使用
Shape circle = new Circle { Radius = 2 };
circle.PrintArea();  // 输出：面积：12.566...（调用具体方法，内部触发重写的抽象方法）

Shape rectangle = new Rectangle { Width = 3, Height = 4 };
rectangle.PrintArea();  // 输出：面积：12

四、接口（Interface）

定义：一种完全抽象的“契约”，仅声明方法、属性、事件等的签名（无任何实现），实现接口的类必须严格遵守契约（实现所有成员）。
核心目的：定义“能力”或“行为”（如“可飞行”“可序列化”）；突破C#单继承限制（一个类可实现多个接口）。

接口特点：

• 关键字interface声明，成员默认public（无需显式修饰）；
• 不能包含字段（只能有属性、方法等），且所有成员无实现；
• 类通过:实现接口，必须实现接口的所有成员；
• 支持多实现（一个类可实现多个接口，用,分隔）。

示例：
接口IFly定义“飞行”能力，Bird和Plane类实现该接口：

// 接口：定义“飞行”契约
public interface IFly
{
    void Fly();  // 仅声明，无实现
    int MaxHeight { get; }  // 属性签名
}

// 鸟类实现“飞行”接口
public class Bird : IFly
{
    public void Fly()
    {
        Console.WriteLine("鸟扇动翅膀飞行");
    }

    public int MaxHeight => 1000;  // 实现属性
}

// 飞机类实现“飞行”接口
public class Plane : IFly
{
    public void Fly()
    {
        Console.WriteLine("飞机靠引擎飞行");
    }

    public int MaxHeight => 10000;  // 实现属性
}

// 使用
IFly bird = new Bird();
bird.Fly();  // 输出：鸟扇动翅膀飞行
Console.WriteLine($"鸟类最大飞行高度：{bird.MaxHeight}米");  // 1000米

IFly plane = new Plane();
plane.Fly();  // 输出：飞机靠引擎飞行
Console.WriteLine($"飞机最大飞行高度：{plane.MaxHeight}米");  // 10000米

抽象类 vs 接口

区别	抽象类（abstract class）	接口（interface）
实现	可包含具体方法（有实现）	所有成员无实现（仅声明）
继承	单继承（一个类只能继承一个抽象类）	多实现（一个类可实现多个接口）
关系	表示“is-a”（是一种）关系（如“狗是动物”）	表示“has-a”（有某种能力）关系（如“鸟会飞”）
字段	可包含字段	不能包含字段（只能有属性签名）

总结

• 封装：隐藏细节，保护数据（“怎么实现的不用管，用我的接口就行”）；
• 继承：复用代码，建立层次（“父类有的我都有，我还能扩展”）；
• 抽象：定义共性，强制实现（“你们都得按我规定的方法做事，但怎么做自己定”）；
• 接口：定义能力，支持多实现（“谁都可以具备这个能力，只要按规则实现”）。

这四大特性结合使用，可构建出灵活、易维护的面向对象程序。