Verschachtelte C#-Klasse

In diesem Tutorial lernen Sie die verschachtelte Klasse in C# anhand von Beispielen kennen.

In C# können wir eine Klasse innerhalb einer anderen Klasse definieren. Sie wird als verschachtelte Klasse bezeichnet. Zum Beispiel

class OuterClass {
  ...
  class InnerClass {
    ...
  }
}

Hier haben wir die Klasse InnerClass erstellt innerhalb der Klasse OuterClass . Die InnerClass wird die verschachtelte Klasse genannt.

Zugangsmitglieder

Um auf Mitglieder der verschachtelten Klassen zugreifen zu können, müssen wir zuerst ihre Objekte erstellen.

1. Objekt der äußeren Klasse erstellen

OuterClass obj1 = new OuterClass();

Hier haben wir das obj1 erstellt Objekt der Klasse OuterClass .

2. Objekt der inneren Klasse erstellen

OuterClass.InnerClass obj2 = new OuterClass.InnerClass();

Sie können sehen, dass wir OuterClass.InnerClass verwendet haben um das obj2 zu erstellen Objekt der inneren Klasse. Das liegt daran, dass InnerClass ist die verschachtelte Klasse von OuterClass .

Sobald wir das Objekt der einzelnen Klassen erstellt haben, können wir den Objektnamen und den Punktoperator verwenden, um auf Mitglieder jeder Klasse zuzugreifen.

Beispiel:Verschachtelte C#-Klasse

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();
 
    }
  }
}

Ausgabe

Car: Bugatti
Engine: Petrol Engine

Im obigen Programm haben wir die Engine verschachtelt Klasse innerhalb der Car Klasse.

Innerhalb der Program Klasse haben wir Objekte sowohl der äußeren als auch der inneren Klasse erstellt.

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

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

Wir haben dann diese Objekte verwendet, um auf die Methoden jeder Klasse zuzugreifen.

sportsCar.displayCar() - Greifen Sie auf die Methode der äußeren Klasse zu, indem Sie das Objekt von Car verwenden
petrolEngine.displayEngine() - Greifen Sie auf die Methode der inneren Klasse zu, indem Sie das Objekt von Engine verwenden

Hinweis :Wir können nicht mit dem Objekt der äußeren Klasse auf die Mitglieder der inneren Klasse zugreifen. Beispiel:

// error code
sportsCar.displayEngine();

Hier können wir nicht auf displayEngine() zugreifen Methode der inneren Klasse Engine mit dem sportsCar Objekt der äußeren Klasse.

Zugriff auf Mitglieder der äußeren Klasse innerhalb der inneren Klasse

Wir können innerhalb der inneren Klasse auf Mitglieder der äußeren Klasse zugreifen. Dazu verwenden wir ein Objekt der äußeren Klasse. Beispiel:

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();
    }
  }
}

Ausgabe

Brand: Bugatti

Im obigen Beispiel haben wir den Engine verschachtelt Klasse innerhalb des Car Klasse. Beachten Sie die Zeile,

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

Hier haben wir das Objekt der Klasse Car verwendet um auf das Feld Marke zuzugreifen .

Zugriff auf statische Mitglieder der äußeren Klasse innerhalb der inneren Klasse

Wenn wir auf statische Member der äußeren Klasse zugreifen müssen, müssen wir ihr Objekt nicht erstellen. Stattdessen können wir direkt den Namen der äußeren Klasse verwenden. Zum Beispiel

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();
    }
  }
}

Ausgabe

Brand: Bugatti

Im obigen Beispiel haben wir den Engine verschachtelt Klasse in Car Klasse. Car hat ein statisches Feld brand .

Hier haben wir auf das statische Feld Marke zugegriffen innerhalb der inneren Klasse (Engine ) mit dem Namen der äußeren Klasse (Car ).

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

Erben der äußeren Klasse

Wie eine reguläre Klasse können wir auch die äußere Klasse erben. Zum Beispiel

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();
    }
  }
}

Ausgabe

Method of Computer class

Im obigen Beispiel haben wir die Klasse Laptop abgeleitet aus der äußeren Klasse Computer .

Aus diesem Grund können wir auf display() zugreifen Methode der Klasse Computer mit dem Objekt der Klasse Laptop .

Erben der inneren Klasse

In C# können wir auch die innere Klasse erben. Zum Beispiel

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();
    }
  }
}

Ausgabe

Method of CPU class

Im obigen Beispiel haben wir den Laptop abgeleitet Klasse aus der inneren Klasse CPU .

Beachten Sie, dass wir den Namen der äußeren Klasse zusammen mit der verschachtelten Klasse verwendet haben, um die innere Klasse zu erben.

class Laptop : Computer.CPU {}

Abstrakte C#-Klasse und -Methode C# Teilklasse und Teilmethode

C Sprache