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 {}