C# 嵌套类

在 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 {
 
  // outer class
  public class Car {

    public void displayCar() {
      Console.WriteLine("Car: Bugatti");
    }
 
    // inner class
    public class Engine {
      public void displayEngine() {
        Console.WriteLine("Engine: Petrol Engine");
      }
    }
  }
  class Program {
    static void Main(string[] args) {

      // create object of outer class
      Car sportsCar = new Car();

      // access method of outer class
      sportsCar.displayCar();
 
      // create object of inner class
      Car.Engine petrolEngine = new Car.Engine();
      
      // access member of inner class
      petrolEngine.displayEngine();
 
      Console.ReadLine();
 
    }
  }
}

输出

Car: Bugatti
Engine: Petrol Engine

在上面的程序中，我们将 `Engine` 类嵌套在了 `Car` 类中。

在 `Program` 类中，我们创建了外部类和内部类的实例。

// object of outer class
Car sportsCar = new Car();

// object of nested class
Car.Engine petrolEngine = new Car.Engine();

然后，我们使用这些实例来访问每个类的方法。

• `sportsCar.displayCar()` - 使用 `Car` 的实例访问外部类的方法
• `petrolEngine.displayEngine()` - 使用 `Engine` 的实例访问内部类的方法

// error code
sportsCar.displayEngine();

在内部类中访问外部类的成员

我们可以在内部类中访问外部类的成员。为此，我们使用外部类的实例。例如：

using System;
namespace CsharpNestedClass {

  // outer class
  public class Car {
 
    public string brand = "Bugatti";

    // nested  class
    public class Engine {
      public void displayCar() {

        // object of outer class
        Car sportsCar = new Car();
        Console.WriteLine("Brand: " + sportsCar.brand);
      }
    }
  }

  class Program {
    static void Main(string[] args) {

       // object of inner class
       Car.Engine engineObj = new Car.Engine();
       engineObj.displayCar();

      Console.ReadLine();
    }
  }
}

输出

Brand: Bugatti

在上面的示例中，我们将 `Engine` 类嵌套在了 `Car` 类中。请注意这一行：

// inside Engine class
Car sportsCar = new Car();
Console.WriteLine("Brand: " + sportsCar.brand);

这里，我们使用了 `Car` 类的实例来访问字段 `brand`。

在内部类中访问外部类的静态成员

如果我们需要访问外部类的静态成员，则无需创建其实例。而是可以直接使用外部类的名称。例如：

using System;
namespace CsharpNestedClass {

  // outer class
  public class Car {
    //static member of outer class
    public static string brand = "Bugatti";

    // nested class
    public class Engine {
      public void display() {
        
        // access static member of outer class
        Console.WriteLine("Brand: " + Car.brand);
      }
    }
  }
  class Program {
    static void Main(string[] args) {

      // object of inner class
       Car.Engine obj = new Car.Engine();
       obj.display();

      Console.ReadLine();
    }
  }
}

输出

Brand: Bugatti

在上面的示例中，我们将 `Engine` 类嵌套在了 `Car` 类中。`Car` 类有一个静态字段 `brand`。

这里，我们在内部类（`Engine`）中通过外部类的名称（`Car`）访问了静态字段 `brand`。

Console.WriteLine("Brand: " + Car.brand);

继承外部类

与普通类一样，我们也可以继承外部类。例如：

using System;
namespace CsharpNestedClass {
 
  // outer class
  class Computer {

    public void display() {
      Console.WriteLine("Method of Computer class");
    }
 
    // nested class
    public class CPU {
 
    }
   }

    class Laptop : Computer {
 
    }

  class Program  {
    static void Main(string[] args) {
 
      // object of derived class
      Laptop obj = new Laptop();
      obj.display();     
 
      Console.ReadLine();
    }
  }
}

输出

Method of Computer class

在上面的示例中，我们从外部类 `Computer` 派生了 `Laptop` 类。

因此，我们能够使用 `Laptop` 类的实例来访问 `Computer` 类的 `display()` 方法。

继承内部类

在 C# 中，我们也可以继承内部类。例如：

using System;
namespace CsharpNestedClass {

  // outer class
  class Computer {

    // nested  class
    public class CPU {
      public void display() {
        Console.WriteLine("Method of CPU class");
      }

    }
  }
    
  // inheriting inner class
  class Laptop : Computer.CPU {

  }

  class Program  {
    static void Main(string[] args) {

      // object of derived class
      Laptop obj = new Laptop();
      obj.display();     

      Console.ReadLine();
    }
  }
}

输出

Method of CPU class

在上面的示例中，我们从内部类 `CPU` 派生了 `Laptop` 类。

请注意，我们使用了外部类的名称以及嵌套类来继承内部类。

class Laptop : Computer.CPU {}