C# 类（Class）

C# 类（Class）——《跟老吕学C#》
C# 类（Class）
一、类的定义
二、类的实例化
1. 类的构造函数
2. 类的实例化与内存分配
三、类的继承
1. 继承的特性
2. 访问修饰符与继承
3. 继承的限制
4. 继承与构造函数
5. 方法的重写（Override）
6. 抽象类与抽象方法
四、类的其他特性
1. 接口实现
2. 抽象类
3. 多态
五、总结

C# 类（Class）
在C#编程语言中，类（Class）是一种基本的数据结构，它允许你定义数据类型以及该类型所可以执行的操作（方法）和包含的数据（字段）。类是面向对象编程（OOP）的核心概念之一，它提供了创建对象（即类的实例）的蓝图。

一、类的定义
在C#中，类的定义通常包括以下几个部分：

访问修饰符：指定类的可见性。常用的有public（任何代码都可以访问）和internal（只能在当前程序集中访问）。
类名：类的唯一标识符。类名通常以大写字母开头，以符合C#的命名规范。
字段：类中的数据成员，用于存储数据。字段可以是任何类型，包括基本数据类型（如int、double等）和其他类类型。
属性：用于访问和修改字段值的特殊方法。属性提供了数据封装，使得类的内部状态对外界是隐藏的。
方法：类中的函数，用于执行某些操作。方法可以访问和修改类的字段和属性。
构造函数和析构函数：构造函数用于初始化对象的状态，而析构函数用于清理对象销毁前需要释放的资源。
下面是一个简单的C#类定义的示例：

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 Person(string name, int age)
    {
        this.name = name;
        this.age = age;
    }

    // 方法
    public void SayHello()
    {
        Console.WriteLine("Hello, my name is " + name + " and I'm " + age + " years old.");
    }

    // 析构函数（在C#中通常使用垃圾回收，不需要显式定义析构函数）
    // ~Person()
    // {
    //     // 清理资源的代码
    // }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

二、类的实例化
在C#中，定义了类之后，就可以创建类的实例（即对象）。在C#中，使用new关键字和类的构造函数来创建对象。例如：

Person person = new Person("Alice", 30);
person.SayHello(); // 输出：Hello, my name is Alice and I'm 30 years old.
1
2
在上面的代码中，我们假设Person是一个已经定义好的类，它有一个接受两个参数（姓名和年龄）的构造函数。当我们使用new Person("Alice", 30)时，我们就创建了一个Person类的新实例，并将其实例化后的对象赋值给person变量。之后，我们可以通过person变量来访问这个对象的属性和方法，比如调用SayHello()方法。

1. 类的构造函数
构造函数是类的一个特殊方法，它在创建类的对象时自动调用。构造函数的名字必须与类名相同，并且没有返回类型。构造函数可以有参数，也可以没有参数。如果类没有定义任何构造函数，编译器会提供一个默认的无参构造函数。

以下是一个简单的Person类的定义，包括一个带有两个参数的构造函数和一个SayHello()方法：

public class Person
{
    public string Name { get; set; }
    public int Age { get; set; }

    // 构造函数
    public Person(string name, int age)
    {
        Name = name;
        Age = age;
    }

    // SayHello 方法
    public void SayHello()
    {
        Console.WriteLine($"Hello, my name is {Name} and I'm {Age} years old.");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
在上面的代码中，Person类有两个属性：Name和Age，以及一个带有两个参数的构造函数和一个SayHello()方法。当我们使用new Person("Alice", 30)创建Person类的实例时，构造函数会被调用，并将传入的参数值赋给对象的Name和Age属性。之后，我们就可以通过person.SayHello()来调用SayHello()方法，并输出相应的信息。

2. 类的实例化与内存分配
在C#中，类的实例化不仅仅是一个简单的调用构造函数的过程，它还涉及到内存的分配和管理。当我们使用new关键字创建类的实例时，系统会在堆内存中为该对象分配一块内存空间，并将对象的引用赋值给相应的变量（如上面的person变量）。这块内存空间包含了对象的所有字段（包括继承自基类的字段）和方法的实现。通过对象的引用，我们可以访问对象的属性和方法，也可以修改对象的字段值。

需要注意的是，当对象不再被引用时（即没有任何变量指向该对象），系统会自动回收该对象所占用的内存空间，以避免内存泄漏。这个过程是由C#的垃圾回收机制自动完成的，我们不需要手动释放对象的内存。

三、类的继承
C#支持类的继承机制，即允许一个类（派生类或子类）继承另一个类（基类或父类）的属性和方法。通过继承，派生类能够重用基类的代码，并在此基础上实现其特有的功能。

1. 继承的特性
代码重用：继承允许派生类直接使用基类的属性和方法，无需重新编写。
扩展性：派生类可以在继承基类的基础上添加新的属性和方法，以满足特定的需求。
多态性：通过继承，可以实现基类和派生类之间的多态性，即使用基类类型的引用指向派生类对象，并调用其方法。
2. 访问修饰符与继承
在C#中，访问修饰符（如public、protected、internal、protected internal和private）决定了类的成员（包括字段、属性、方法等）在继承关系中的可见性。

public：成员在任何地方都是可见的。
protected：成员在基类和派生类中是可见的，但在类外部是不可见的。
internal：成员在同一程序集中是可见的，但在其他程序集中是不可见的。
protected internal：成员在同一程序集或派生类中是可见的，但在其他程序集和类外部是不可见的。
private：成员仅在当前类中是可见的。
3. 继承的限制
虽然继承带来了许多好处，但也存在一些限制：

C#不支持多重继承，即一个类不能同时继承多个基类。但可以通过接口实现类似的功能。
派生类不能继承基类的私有成员。
构造函数和析构函数是类的特殊方法，它们不能被直接继承，但可以在派生类中被调用。
4. 继承与构造函数
在C#中，派生类的构造函数会隐式调用基类的无参数构造函数。如果基类没有无参数构造函数或派生类需要传递参数给基类构造函数，则需要使用base关键字显式调用基类构造函数。

5. 方法的重写（Override）
当派生类需要改变基类方法的实现时，可以使用override关键字来重写基类方法。这样，当使用基类类型的引用指向派生类对象并调用该方法时，将执行派生类中的实现。

6. 抽象类与抽象方法
除了普通的类和方法外，C#还支持抽象类和抽象方法。抽象类不能被实例化，只能作为其他类的基类。抽象方法没有具体的实现，需要在派生类中被重写。抽象类和抽象方法通常用于定义一组具有共同特性的类和方法，但具体的实现可能因派生类而异。

以下是一个使用继承的示例：

public class Person
{
    // Person类的定义...
}

public class Employee : Person
{
    private string jobId;

    public string JobId
    {
        get { return jobId; }
        set { jobId = value; }
    }

    public Employee(string name, int age, string jobId) : base(name, age)
    {
        this.jobId = jobId;
    }

    public override void SayHello()
    {
        Console.WriteLine("Hello, I'm an employee. My name is " + Name + ", my job ID is " + JobId + ", and I'm " + Age + " years old.");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
在上面的示例中，Employee类继承自Person类，并添加了自己的字段和方法。通过base关键字，Employee类的构造函数可以调用Person类的构造函数来初始化继承的字段。同时，Employee类还重写了SayHello方法，以提供自己的实现。

四、类的其他特性
除了上述基本功能外，C#的类还支持许多其他特性，如接口实现、抽象类、多态等。

1. 接口实现
接口是一种只包含方法声明不包含方法实现的引用类型。一个类可以实现一个或多个接口，并提供这些接口中定义的方法的具体实现。通过接口，可以实现多重继承的效果，即一个类可以继承多个接口。

2. 抽象类
抽象类是一种特殊的类，它不能被实例化（即不能创建抽象类的对象）。抽象类通常包含一些抽象方法（只有方法声明没有方法实现的方法），这些方法必须由派生类来实现。抽象类还可以包含非抽象方法、字段、属性等。

3. 多态
多态是面向对象编程的三大特性之一，它允许我们使用父类类型的引用指向子类对象，并调用子类对象的方法。通过多态，我们可以实现代码的复用和扩展性。

五、总结
C#中的类是一种强大的工具，它允许我们定义复杂的数据类型并封装相关的操作。通过类的继承、接口实现、抽象类和多态等特性，我们可以创建出更加灵活、可维护的代码。在编写C#程序时，熟练掌握类的使用是非常重要的。希望本文对你理解C#中的类有所帮助。
————————————————

                            版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
                        
原文链接：https://blog.csdn.net/molangmolang/article/details/140070785