C#语言入门-task3 ：C# 语言的面向对象技术

C# 面向对象编程技术概述

C# 是一种现代化的面向对象编程语言，提供了丰富的特性来支持面向对象的编程范式。以下是 C# 中面向对象编程的核心概念和技术：

核心概念

1. 类与对象

类是对象的蓝图，定义了对象的属性和行为。对象是类的实例。

// 定义一个类
public class Person
{
    // 字段
    private string name;
    private int age;
    
    // 属性
    public string Name
    {
        get { return name; }
        set { name = value; }
    }
    
    public int Age
    {
        get { return age; }
        set 
        {
            if (value >= 0)
                age = value;
            else
                throw new ArgumentException("年龄不能为负数");
        }
    }
    
    // 构造函数
    public Person(string name, int age)
    {
        Name = name;
        Age = age;
    }
    
    // 方法
    public void SayHello()
    {
        Console.WriteLine($"你好，我是{Name}，今年{Age}岁。");
    }
}

// 创建对象并使用
Person person = new Person("张三", 30);
person.SayHello(); // 输出: 你好，我是张三，今年30岁。

2. 继承

继承允许创建一个新类（子类）来继承现有类（父类）的属性和方法。

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

// 子类
public class Dog : Animal
{
    public Dog(string name) : base(name) { }
    
    // 新增方法
    public void Bark()
    {
        Console.WriteLine($"{Name}正在叫。");
    }
}

// 使用继承
Dog dog = new Dog("旺财");
dog.Eat();  // 输出: 旺财正在吃东西。
dog.Bark(); // 输出: 旺财正在叫。

3. 多态

多态允许通过父类类型引用子类对象，并在运行时决定调用哪个方法。

// 基类
public abstract class Shape
{
    public abstract double Area(); // 抽象方法
}

// 子类
public class Circle : Shape
{
    public double Radius { get; set; }
    
    public Circle(double radius)
    {
        Radius = radius;
    }
    
    public override double Area()
    {
        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 double Area()
    {
        return Width * Height;
    }
}

// 使用多态
Shape circle = new Circle(5);
Shape rectangle = new Rectangle(4, 6);

Console.WriteLine($"圆的面积: {circle.Area()}");    // 输出: 圆的面积: 78.5398163397448
Console.WriteLine($"矩形的面积: {rectangle.Area()}"); // 输出: 矩形的面积: 24

4. 封装

封装通过访问修饰符（如 public, private, protected）控制类成员的访问级别。

public class BankAccount
{
    private double balance; // 私有字段，外部无法直接访问
    
    public void Deposit(double amount)
    {
        if (amount > 0)
            balance += amount;
    }
    
    public bool Withdraw(double amount)
    {
        if (amount > 0 && balance >= amount)
        {
            balance -= amount;
            return true;
        }
        return false;
    }
    
    public double GetBalance()
    {
        return balance;
    }
}

// 使用封装
BankAccount account = new BankAccount();
account.Deposit(1000);
bool success = account.Withdraw(500);
Console.WriteLine($"取款成功: {success}, 余额: {account.GetBalance()}"); 
// 输出: 取款成功: True, 余额: 500

高级特性

1. 接口

接口定义了一组方法签名，但不包含实现。类可以实现多个接口。

// 定义接口
public interface IAnimal
{
    void Eat();
    void Sleep();
}

// 实现接口
public class Cat : IAnimal
{
    public void Eat()
    {
        Console.WriteLine("猫吃鱼");
    }
    
    public void Sleep()
    {
        Console.WriteLine("猫睡觉");
    }
}

// 使用接口
IAnimal cat = new Cat();
cat.Eat();   // 输出: 猫吃鱼
cat.Sleep(); // 输出: 猫睡觉

2. 抽象类

抽象类不能实例化，只能作为基类。它可以包含抽象方法和非抽象方法。

// 抽象类
public abstract class Vehicle
{
    public abstract void Start(); // 抽象方法
    
    public void Stop()
    {
        Console.WriteLine("车辆停止");
    }
}

// 具体类
public class Car : Vehicle
{
    public override void Start()
    {
        Console.WriteLine("汽车启动");
    }
}

// 使用抽象类
Vehicle car = new Car();
car.Start(); // 输出: 汽车启动
car.Stop();  // 输出: 车辆停止

3. 事件与委托

委托是一种类型，它可以引用一个或多个方法。事件基于委托，用于实现发布-订阅模式。

// 定义委托
public delegate void EventHandler(string message);

// 发布者类
public class Publisher
{
    // 定义事件
    public event EventHandler? MyEvent;
    
    public void RaiseEvent()
    {
        MyEvent?.Invoke("事件被触发");
    }
}

// 订阅者类
public class Subscriber
{
    public void HandleEvent(string message)
    {
        Console.WriteLine($"收到消息: {message}");
    }
}

// 使用事件和委托
Publisher publisher = new Publisher();
Subscriber subscriber = new Subscriber();

// 订阅事件
publisher.MyEvent += subscriber.HandleEvent;

// 触发事件
publisher.RaiseEvent(); // 输出: 收到消息: 事件被触发

4. 特性（Attributes）

特性用于为程序元素（类、方法、属性等）添加元数据。

// 自定义特性
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method)]
public class DescriptionAttribute : Attribute
{
    public string Description { get; }
    
    public DescriptionAttribute(string description)
    {
        Description = description;
    }
}

// 应用特性
[Description("这是一个用户类")]
public class User
{
    [Description("获取用户名")]
    public string GetUserName()
    {
        return "John Doe";
    }
}

// 反射获取特性信息
Type type = typeof(User);
DescriptionAttribute? classAttr = type.GetCustomAttribute<DescriptionAttribute>();
Console.WriteLine($"类描述: {classAttr?.Description}");

MethodInfo method = type.GetMethod("GetUserName");
DescriptionAttribute? methodAttr = method?.GetCustomAttribute<DescriptionAttribute>();
Console.WriteLine($"方法描述: {methodAttr?.Description}");

// 输出:
// 类描述: 这是一个用户类
// 方法描述: 获取用户名

总结

C# 的面向对象编程提供了丰富的特性，包括类、继承、多态、封装、接口、抽象类、事件委托和特性等。这些特性使得代码更加模块化、可维护和可扩展，是构建大型应用程序的基础。