C# 嵌套类
- 定义嵌套类：在C#中，可以在一个类（外部类）内部定义另一个类（嵌套类），例如将
InnerClass定义在OuterClass内部。 - 访问嵌套类成员：要访问嵌套类的成员，首先需要创建外部类和内部类的对象，然后使用对象和点运算符访问各自的成员。
- 内部类访问外部类成员：内部类可以访问外部类的成员。对于外部类的静态成员，可以直接使用外部类的名称进行访问，而非静态成员则需要创建外部类的对象。
在 C# 中，我们可以在另一个类内定义一个类。这被称为嵌套类。例如，
class OuterClass {
...
class InnerClass {
...
}
}
这里，我们在 OuterClass 类内创建了 InnerClass 类。InnerClass 被称为嵌套类。
访问成员
要访问嵌套类的成员，我们首先需要创建它们的对象。
1. 创建外部类的对象
OuterClass obj1 = new OuterClass();
这里，我们创建了 OuterClass 类的 obj1 对象。
2. 创建内部类的对象
OuterClass.InnerClass obj2 = new OuterClass.InnerClass();
可以看到，我们使用了 OuterClass.InnerClass 来创建内部类的 obj2 对象。这是因为 InnerClass 是 OuterClass 的嵌套类。
一旦我们创建了各个类的对象，我们就可以使用对象名称和点运算符来访问每个类的成员。
示例：C# 嵌套类
using System;
namespace CsharpNestedClass {
// 外部类
public class Car {
public void displayCar() {
Console.WriteLine("汽车: Bugatti");
}
// 内部类
public class Engine {
public void displayEngine() {
Console.WriteLine("引擎: 汽油引擎");
}
}
}
class Program {
static void Main(string[] args) {
// 创建外部类的对象
Car sportsCar = new Car();
// 访问外部类的方法
sportsCar.displayCar();
// 创建内部类的对象
Car.Engine petrolEngine = new Car.Engine();
// 访问内部类的成员
petrolEngine.displayEngine();
Console.ReadLine();
}
}
}
输出
汽车: Bugatti
引擎: 汽油引擎
在上述程序中，我们将 Engine 类嵌套在 Car 类内。
在 Program 类内，我们创建了外部类和内部类的对象。
// 外部类的对象
Car sportsCar = new Car();
// 嵌套类的对象
Car.Engine petrolEngine = new Car.Engine();
然后我们使用这些对象来访问每个类的方法。
sportsCar.displayCar()- 使用Car的对象访问外部类方法petrolEngine.displayEngine()- 使用Engine的对象访问内部类方法
注意：我们不能使用外部类的对象来访问内部类的成员。例如，
// 错误代码
sportsCar.displayEngine();
这里，我们不能使用外部类的 sportsCar 对象来访问内部类 Engine 的 displayEngine() 方法。
在内部类中访问外部类成员
我们可以在内部类中访问外部类的成员。为此我们使用外部类的对象。例如，
using System;
namespace CsharpNestedClass {
// 外部类
public class Car {
public string brand = "Bugatti";
// 嵌套类
public class Engine {
public void displayCar() {
// 外部类的对象
Car sportsCar = new Car();
Console.WriteLine("品牌: " + sportsCar.brand);
}
}
}
class Program {
static void Main(string[] args) {
// 内部类的对象
Car.Engine engineObj = new Car.Engine();
engineObj.displayCar();
Console.ReadLine();
}
}
}
输出
品牌: Bugatti
在上述示例中，我们将 Engine 类嵌套在 Car 类内。注意这行代码，
// 在 Engine 类内部
Car sportsCar = new Car();
Console.WriteLine("品牌: " + sportsCar.brand);
在这里，我们使用了 Car 类的对象来访问字段 brand。
在内部类中访问外部类的静态成员
如果我们需要访问外部类的静态成员，就不需要创建它的对象。相反，我们可以直接使用外部类的名称。例如，
using System;
namespace CsharpNestedClass {
// 外部类
public class Car {
// 外部类的静态成员
public static string brand = "Bugatti";
// 嵌套类
public class Engine {
public void display() {
// 访问外部类的静态成员
Console.WriteLine("品牌: " + Car.brand);
}
}
}
class Program {
static void Main(string[] args) {
// 内部类的对象
Car.Engine obj = new Car.Engine();
obj.display();
Console.ReadLine();
}
}
}
输出
品牌: Bugatti
在上面的示例中，我们在 Car 类中嵌套了 Engine 类。Car 有一个静态字段 brand。
在这里，我们在内部类（Engine）中使用了外部类（Car）的名称来访问静态字段 brand。
Console.WriteLine("品牌: " + Car.brand);
继承外部类
像常规类一样，我们也可以继承外部类。例如，
using System;
namespace CsharpNestedClass {
// 外部类
class Computer {
public void display() {
Console.WriteLine("Computer 类的方法");
}
// 嵌套类
public class CPU {
}
}
class Laptop : Computer {
}
class Program {
static void Main(string[] args) {
// 派生类的对象
Laptop obj = new Laptop();
obj.display();
Console.ReadLine();
}
}
}
输出
Computer 类的方法
在上述示例中，我们从外部类 Computer 派生了 Laptop 类。
由于这个原因，我们可以使用 Laptop 类的对象来访问 Computer 类的 display() 方法。
继承内部 类
在 C# 中，我们也可以继承内部类。例如，
using System;
namespace CsharpNestedClass {
// 外部类
class Computer {
// 嵌套类
public class CPU {
public void display() {
Console.WriteLine("CPU 类的方法");
}
}
}
// 继承内部类
class Laptop : Computer.CPU {
}
class Program {
static void Main(string[] args) {
// 派生类的对象
Laptop obj = new Laptop();
obj.display();
Console.ReadLine();
}
}
}
输出
CPU 类的方法
在上述示例中，我们从内部类 CPU 派生了 Laptop 类。
请注意，我们在继承内部类时使用了外部类的名称。
class Laptop : Computer.CPU {}