一、类和对象的基本概念
在C#中，类是面向对象编程的基础构建块，它是创建对象的蓝图或模板。对象则是类的具体实例，包含实际的数据和行为。
// 定义一个简单的Person类
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 { age = value; }
}
// 方法（定义行为）
public void Introduce()
{
Console.WriteLine($"大家好，我是{name}，今年{age}岁。");
}
}二、创建和使用对象
1. 对象实例化
使用new关键字创建类的实例：
// 创建Person对象
Person person1 = new Person();
person1.Name = "张三";
person1.Age = 25;
// 使用对象方法
person1.Introduce(); // 输出：大家好，我是张三，今年25岁。2. 对象初始化器
C#提供了简洁的对象初始化语法：
Person person2 = new Person
{
Name = "李四",
Age = 30
};三、类的成员
1. 字段
存储对象状态的变量：
public class Car
{
private string model; // 私有字段
public string color; // 公有字段
}2. 属性
提供对字段的安全访问：
public class BankAccount
{
private decimal balance;
public decimal Balance
{
get { return balance; }
private set { balance = value; } // 只能在类内部设置
}
// 自动属性（编译器自动生成后备字段）
public string AccountNumber { get; set; }
}3. 方法
定义对象的行为：
public class Calculator
{
public int Add(int a, int b)
{
return a + b;
}
// 方法重载
public double Add(double a, double b)
{
return a + b;
}
}4. 构造函数
初始化对象的特殊方法：
public class Student
{
public string Name { get; set; }
public int Grade { get; set; }
// 默认构造函数
public Student()
{
Name = "未命名";
Grade = 1;
}
// 带参数的构造函数
public Student(string name, int grade)
{
Name = name;
Grade = grade;
}
}
// 使用
Student stu1 = new Student(); // 使用默认构造函数
Student stu2 = new Student("王五", 3); // 使用带参构造函数四、静态成员
属于类本身而非实例的成员：
public class MathHelper
{
// 静态字段
public static readonly double PI = 3.14159;
// 静态方法
public static int Max(int a, int b)
{
return a > b ? a : b;
}
}
// 使用静态成员（无需创建实例）
double pi = MathHelper.PI;
int max = MathHelper.Max(5, 8);五、this关键字
引用当前实例的成员：
public class Rectangle
{
private double length;
private double width;
public Rectangle(double length, double width)
{
this.length = length; // 使用this区分字段和参数
this.width = width;
}
public double GetArea()
{
return this.length * this.width; // 明确引用实例成员
}
}六、部分类(partial class)
将类的定义拆分到多个文件中：
// File1.cs
public partial class Employee
{
public string Name { get; set; }
}
// File2.cs
public partial class Employee
{
public decimal Salary { get; set; }
public void DisplayInfo()
{
Console.WriteLine($"{Name}的工资是{Salary}");
}
}七、嵌套类
在类内部定义另一个类：
public class University
{
public string Name { get; set; }
// 嵌套类
public class Department
{
public string DeptName { get; set; }
public void ShowInfo()
{
Console.WriteLine($"这是{DeptName}系");
}
}
}
// 使用嵌套类
University.Department csDept = new University.Department();
csDept.DeptName = "计算机科学";
csDept.ShowInfo();八、对象生命周期
1. 创建对象
// 在堆上分配内存并调用构造函数
Person p = new Person();2. 使用对象
p.Name = "赵六";
p.Age = 28;
p.Introduce();3. 销毁对象
C#使用垃圾回收器(GC)自动管理内存，但可以定义析构函数：
public class ResourceHolder
{
// 析构函数（由GC调用）
~ResourceHolder()
{
Console.WriteLine("对象被销毁");
}
}九、综合示例
using System;
class Program
{
static void Main()
{
// 创建图书对象
Book book1 = new Book("C#编程指南", "张教授", 59.9m);
Book book2 = new Book("算法导论", "李博士", 99.0m);
// 使用对象方法
book1.DisplayInfo();
book2.DisplayInfo();
// 修改对象属性
book1.Price = 49.9m;
Console.WriteLine($"《{book1.Title}》的新价格：{book1.Price}");
// 使用静态成员
Console.WriteLine($"当前库存图书数量：{Book.TotalBooks}");
}
}
public class Book
{
// 静态字段
private static int totalBooks;
// 属性
public string Title { get; }
public string Author { get; set; }
public decimal Price { get; set; }
// 静态属性
public static int TotalBooks => totalBooks;
// 构造函数
public Book(string title, string author, decimal price)
{
Title = title;
Author = author;
Price = price;
totalBooks++;
}
// 方法
public void DisplayInfo()
{
Console.WriteLine($"《{Title}》 作者：{Author} 价格：{Price}元");
}
// 静态方法
public static void ResetCounter()
{
totalBooks = 0;
}
}十、最佳实践
- 命名规范：类名使用PascalCase，字段和方法使用camelCase
- 封装原则：尽量将字段设为private，通过属性暴露
- 单一职责：每个类应该只负责一件事情
- 合理使用静态成员：避免过度使用静态成员导致代码难以测试
- 对象初始化：优先使用对象初始化器简化代码
掌握类和对象的使用是C#编程的基础，通过合理设计类结构和对象交互，可以构建出结构清晰、易于维护的应用程序。