在这篇文章中，我们将深入学习C#中的类与对象。我们将详细了解它们的应用特点，探讨它们在不同场景下的使用方法，并通过丰富的示例和注释，展示如何在实际编程中有效地运用类与对象。

---

类与对象的基本概念

1. 类（Class）

• 定义：类是对一类事物的抽象描述，包含了数据（属性）和行为（方法）。
• 作用：定义对象的模板或蓝图，指定对象具有的属性和方法。

2. 对象（Object）

• 定义：对象是类的实例，是具体存在的实体。
• 作用：通过对象，我们可以访问类中定义的属性和方法，进行实际操作。

---

类的特性

封装性（Encapsulation）

封装是将数据和方法包装在一起，隐藏对象的内部实现，只对外暴露必要的接口。

示例：

C#
public class Person
{
    // 私有字段，外部无法直接访问
    private string name;
    private int age;

    // 公有属性，通过 get 和 set 方法访问私有字段
    public string Name
    {
        get { return name; }
        set { name = value; }
    }

    public int Age
    {
        get { return age; }
        set
        {
            // 设置条件，年龄不能为负数
            if (value >= 0)
            {
                age = value;
            }
            else
            {
                Console.WriteLine("年龄不能为负数！");
            }
        }
    }

    // 公有方法
    public void Introduce()
    {
        Console.WriteLine($"大家好，我叫{name}，今年{age}岁。");
    }
}

C#
internal class Program
{
    static void Main(string[] args)
    {
        Person person = new Person();
        person.Name = "李四";
        person.Age = 30;
        person.Introduce();
    }
}

继承性（Inheritance）

继承允许一个类（子类）继承另一个类（父类）的属性和方法，从而实现代码的重用和拓展。

示例：

C#
// 父类
public class Animal
{
    public string Name { get; set; }

    public void Eat()
    {
        Console.WriteLine($"{Name} 正在吃东西。");
    }
}

// 子类
public class Cat : Animal
{
    public void Meow()
    {
        Console.WriteLine($"{Name} 正在喵喵叫。");
    }
}

public class Dog : Animal
{
    public void Bark()
    {
        Console.WriteLine($"{Name} 正在汪汪叫。");
    }
}

C#
internal class Program
{
    static void Main(string[] args)
    {
        Cat cat = new Cat();
        cat.Name = "小花";
        cat.Eat();    // 继承自父类的方法
        cat.Meow();   // 子类自有的方法

        Dog dog = new Dog();
        dog.Name = "大黑";
        dog.Eat();    // 继承自父类的方法
        dog.Bark();   // 子类自有的方法
    }
}

多态性（Polymorphism）

多态性指同一操作作用于不同的对象，可以产生不同的解释和执行结果。实现多态有两种方式：方法重载和方法重写。

方法重载（Overloading）

同一类中，方法名相同，但参数列表不同。

示例：

C#
public class Calculator
{
    // 加法：两个整数
    public int Add(int x, int y)
    {
        return x + y;
    }

    // 加法：三个整数
    public int Add(int x, int y, int z)
    {
        return x + y + z;
    }

    // 加法：两个双精度数
    public double Add(double x, double y)
    {
        return x + y;
    }
}

C#
internal class Program
{
    static void Main(string[] args)
    {
        Calculator calc = new Calculator();
        Console.WriteLine(calc.Add(1, 2));            // 输出：3
        Console.WriteLine(calc.Add(1, 2, 3));         // 输出：6
        Console.WriteLine(calc.Add(1.5, 2.5));        // 输出：4.0
    }
}

方法重写（Overriding）

子类重写父类的虚方法，实现自己特定的功能。

示例：

C#
public class Shape
{
    // 虚方法，可被子类重写
    public virtual void Draw()
    {
        Console.WriteLine("绘制形状。");
    }
}

public class Circle : Shape
{
    // 重写父类的 Draw 方法
    public override void Draw()
    {
        Console.WriteLine("绘制圆形。");
    }
}

public class Rectangle : Shape
{
    // 重写父类的 Draw 方法
    public override void Draw()
    {
        Console.WriteLine("绘制矩形。");
    }
}

C#
internal class Program
{
    static void Main(string[] args)
    {
        Shape shape1 = new Circle();
        Shape shape2 = new Rectangle();

        shape1.Draw();
        shape2.Draw(); 
    }
}

---

类与对象的应用场景

模拟现实实体

通过类与对象，我们可以模拟现实世界中的实体，如学生、教师、图书等。

示例：学生类

C#
public class Student
{
    public string Name { get; set; }   // 姓名
    public int Age { get; set; }       // 年龄
    public string StudentID { get; set; }  // 学号

    public void Study()
    {
        Console.WriteLine($"{Name} 正在学习。");
    }

    public void TakeExam()
    {
        Console.WriteLine($"{Name} 正在参加考试。");
    }
}

信息隐藏和数据保护

通过封装，我们可以控制对对象数据的访问，保护数据的完整性。

示例：账户类

C#
public class Account
{
    private decimal balance;  // 账户余额

    public decimal Balance
    {
        get { return balance; }
        // 余额只能通过存取款方法修改，不允许外部直接设置
        private set { balance = value; }
    }

    public void Deposit(decimal amount)
    {
        if (amount > 0)
        {
            Balance += amount;
            Console.WriteLine($"存款：{amount} 元，当前余额：{Balance} 元。");
        }
        else
        {
            Console.WriteLine("存款金额必须大于零！");
        }
    }

    public void Withdraw(decimal amount)
    {
        if (amount > 0 && amount <= Balance)
        {
            Balance -= amount;
            Console.WriteLine($"取款：{amount} 元，当前余额：{Balance} 元。");
        }
        else
        {
            Console.WriteLine("取款金额无效或余额不足！");
        }
    }
}

代码的重用和扩展

通过继承，我们可以在已有类的基础上添加新的功能，避免重复编码。

示例：员工继承

C#
// 员工基类
public class Employee
{
    public string Name { get; set; }
    public int ID { get; set; }

    public void Work()
    {
        Console.WriteLine($"{Name} 正在工作。");
    }
}

// 经理类，继承自员工类
public class Manager : Employee
{
    public void Manage()
    {
        Console.WriteLine($"{Name} 正在管理团队。");
    }
}

// 开发人员类，继承自员工类
public class Developer : Employee
{
    public void WriteCode()
    {
        Console.WriteLine($"{Name} 正在编写代码。");
    }
}

C#
internal class Program
{
    static void Main(string[] args)
    {
        Manager manager = new Manager();
        manager.Name = "赵经理";
        manager.Work();    // 基类方法
        manager.Manage();  // 子类方法


        Developer developer = new Developer();
        developer.Name = "孙程序员";
        developer.Work();       // 基类方法
        developer.WriteCode();  // 子类方法

    }
}

灵活的编程和扩展性

利用多态性，可以编写通用代码，实现不同对象的灵活调用。

示例：日志记录器

C#
// 抽象的日志记录器
public abstract class Logger
{
    public abstract void Log(string message);
}

public class ConsoleLogger : Logger
{
    public override void Log(string message)
    {
        Console.WriteLine($"控制台日志：{message}");
    }
}

public class FileLogger : Logger
{
    public override void Log(string message)
    {
        // 假设将日志写入文件
        Console.WriteLine($"文件日志：{message}");
    }
}

public class DatabaseLogger : Logger
{
    public override void Log(string message)
    {
        // 假设将日志写入数据库
        Console.WriteLine($"数据库日志：{message}");
    }
}

使用：

C#
internal class Program
{
    static void Main(string[] args)
    {
        List<Logger> loggers = new List<Logger>
        {
            new ConsoleLogger(),
            new FileLogger(),
            new DatabaseLogger()
        };

        foreach (var logger in loggers)
        {
            logger.Log("系统启动。");
        }
    }
}

---

总结

通过本文的学习，我们深入了解了C#中类与对象的概念和应用。我们探讨了面向对象编程的三大特性：封装、继承和多态，并通过丰富的示例和详细的注释，展示了它们在实际编程中的应用。

关键点回顾：

• 封装性：保护数据的安全，提供统一的访问接口。
• 继承性：实现代码的重用和拓展，降低维护成本。
• 多态性：提高代码的灵活性和可扩展性，编写通用代码。

面向对象编程是现代程序设计的重要思想，合理运用类与对象可以让我们的程序更具有模块化、可维护性和可拓展性。在实际开发中，应根据需求合理设计类的结构，充分利用面向对象的特性，提高代码质量和开发效率。