C#教程6：面向对象四大特性

一、封装(Encapsulation)

概念

封装是将数据和操作数据的方法绑定在一起，对外部隐藏内部实现细节，只暴露必要的接口。

特点

• 使用访问修饰符控制成员的可见性
• 通过属性提供对字段的受控访问
• 保护数据不被外部直接修改

代码示例

using System;

public class Student
{
    // 私有字段 - 封装数据
    private string name;
    private int age;
    private double score; 
    // 公共属性 - 提供受控访问
    public string Name
    {
        get { return name; }
        set { name = value; }
    }
    public int Age
    {
        get { return age; }
        set 
        { 
            if (value > 0 && value < 120)
                age = value;
            else
                Console.WriteLine("年龄无效！");
        }
    }
    public double Score
    {
        get { return score; }
        set 
        { 
            if (value >= 0 && value <= 100)
                score = value;
            else
                Console.WriteLine("分数无效！");
        }
    }
    // 构造函数
    public Student(string name, int age, double score)
    {
        Name = name;
        Age = age;
        Score = score;
    }
    // 公共方法
    public void DisplayInfo()
    {
        Console.WriteLine($"学生：{name}，年龄：{age}，分数：{score}");
    }
}

class Program
{
    static void Main(string[] args)
    {
        Student student = new Student("张三", 18, 85);
        student.DisplayInfo();
        
        // 通过属性修改数据
        student.Score = 95;
        student.DisplayInfo();
        
        // 无效数据会被拒绝
        student.Age = -5;  // 输出：年龄无效！
        student.Score = 120;  // 输出：分数无效！
        
        Console.ReadKey();
    }
}

二、继承(Inheritance)

概念

继承允许一个类（派生类）基于另一个类（基类）来定义，获得基类的特性并可以添加自己的特性。

特点

• 代码重用，减少重复代码
• 建立类的层次结构
• 使用:表示继承关系
• 使用base调用基类的构造函数和方法

代码示例

using System;
// 基类：动物
public class Animal
{
    public string Name { get; set; }
    
    public Animal(string name)
    {
        Name = name;
    }
    public void Eat()
    {
        Console.WriteLine($"{Name}正在吃东西");
    }
    public void Sleep()
    {
        Console.WriteLine($"{Name}正在睡觉");
    }
}

// 派生类：狗
public class Dog : Animal
{
    public string Breed { get; set; }
    // 调用基类构造函数
    public Dog(string name, string breed) : base(name)
    {
        Breed = breed;
    }
    // 派生类特有的方法
    public void Bark()
    {
        Console.WriteLine($"{Breed}犬{Name}：汪汪汪！");
    }
}

// 派生类：猫
public class Cat : Animal
{
    // 调用基类构造函数
    public Cat(string name) : base(name)
    {
    }
    // 派生类特有的方法
    public void Meow()
    {
        Console.WriteLine($"猫{Name}：喵喵喵！");
    }
}

class Program
{
    static void Main(string[] args)
    {
        // 创建派生类对象
        Dog dog = new Dog("旺财", "金毛");
        dog.Eat();    // 继承自基类的方法
        dog.Sleep();  // 继承自基类的方法
        dog.Bark();   // 派生类特有的方法
        Cat cat = new Cat("咪咪");
        cat.Eat();    // 继承自基类的方法
        cat.Sleep();  // 继承自基类的方法
        cat.Meow();   // 派生类特有的方法
        Console.ReadKey();
    }
}

三、多态(Polymorphism)

概念

多态允许使用基类引用调用派生类对象的方法，方法的行为取决于对象的实际类型。

特点

• 通过方法重写实现运行时多态
• 使用virtual关键字在基类中声明可重写的方法
• 使用override关键字在派生类中重写方法
• 通过方法重载实现编译时多态

代码示例

using System;

// 基类
public class Shape
{
    // 虚方法，可被派生类重写
    public virtual void Draw()
    {
        Console.WriteLine("绘制形状");
    }
    public virtual double CalculateArea()
    {
        return 0;
    }
}

// 派生类：圆形
public class Circle : Shape
{
    public double Radius { get; set; }
    public Circle(double radius)
    {
        Radius = radius;
    }
    // 重写基类的虚方法
    public override void Draw()
    {
        Console.WriteLine($"绘制半径为{Radius}的圆");
    }
    public override double CalculateArea()
    {
        return Math.PI * Radius * Radius;
    }
}

// 派生类：矩形
public class Rectangle : Shape
{
    public double Width { get; set; }
    public double Height { get; set; }
    public Rectangle(double width, double height)
    {
        Width = width;
        Height = height;
    }
    // 重写基类的虚方法
    public override void Draw()
    {
        Console.WriteLine($"绘制宽为{Width}、高为{Height}的矩形");
    }
    public override double CalculateArea()
    {
        return Width * Height;
    }
}

class Program
{
    static void Main(string[] args)
    {
        // 创建对象
        Circle circle = new Circle(5);
        Rectangle rectangle = new Rectangle(4, 6);
        // 直接调用方法
        circle.Draw();
        rectangle.Draw();        
        // 多态性：基类引用指向派生类对象
        Shape shape1 = new Circle(3);
        Shape shape2 = new Rectangle(2, 7);        
        // 相同的方法调用，不同的行为
        shape1.Draw();  // 调用Circle的Draw方法
        shape2.Draw();  // 调用Rectangle的Draw方法        
        Console.WriteLine($"圆的面积：{shape1.CalculateArea():F2}");
        Console.WriteLine($"矩形的面积：{shape2.CalculateArea():F2}");        
        Console.ReadKey();
    }
}

四、抽象(Abstraction)

概念

抽象是将复杂系统简化的方法，通过只关注对象的本质特征而忽略其他细节来实现。

特点

• 抽象类：使用abstract关键字定义，不能被实例化
• 抽象方法：没有实现，必须由派生类实现
• 接口：使用interface关键字定义，只包含方法签名

代码示例

using System;

// 抽象类
public abstract class Animal
{
    public string Name { get; set; }    
    // 构造函数
    public Animal(string name)
    {
        Name = name;
    }    
    // 普通方法
    public void Sleep()
    {
        Console.WriteLine($"{Name}正在睡觉");
    }    
    // 抽象方法，必须由子类实现
    public abstract void MakeSound();
}

// 具体类：狗
public class Dog : Animal
{
    public Dog(string name) : base(name)
    {
    }    
    // 实现抽象方法
    public override void MakeSound()
    {
        Console.WriteLine($"{Name}：汪汪汪！");
    }
}

// 具体类：猫
public class Cat : Animal
{
    public Cat(string name) : base(name)
    {
    }    
    // 实现抽象方法
    public override void MakeSound()
    {
        Console.WriteLine($"{Name}：喵喵喵！");
    }
}

// 接口
public interface IFlyable
{
    void Fly();
}

// 实现接口的类
public class Bird : Animal, IFlyable
{
    public Bird(string name) : base(name)
    {
    }    
    public override void MakeSound()
    {
        Console.WriteLine($"{Name}：叽叽喳喳！");
    }    
    // 实现接口方法
    public void Fly()
    {
        Console.WriteLine($"{Name}在天空中飞翔");
    }
}

class Program
{
    static void Main(string[] args)
    {
        // Animal animal = new Animal("动物"); // 错误！抽象类不能被实例化
        
        Dog dog = new Dog("旺财");
        dog.Sleep();      // 继承自抽象类的方法
        dog.MakeSound();  // 实现的抽象方法        
        Cat cat = new Cat("咪咪");
        cat.Sleep();
        cat.MakeSound();        
        Bird bird = new Bird("小鸟");
        bird.Sleep();
        bird.MakeSound();
        bird.Fly();       // 接口方法        
        // 多态
        Animal[] animals = new Animal[] { dog, cat, bird };
        foreach (Animal animal in animals)
        {
            animal.MakeSound();  // 调用各自实现的方法
        }        
        // 接口引用
        IFlyable flyable = bird;
        flyable.Fly();        
        Console.ReadKey();
    }
}

五、四大特性的对比

特性	主要目的	关键字	核心优势
封装	隐藏实现细节，保护数据	private, public, protected	安全性、模块化
继承	代码重用，建立类层次	: (冒号)	减少重复代码
多态	同一接口，不同实现	virtual, override	灵活性、可扩展性
抽象	关注本质，忽略细节	abstract, interface	简化复杂系统