C#-Klasse und -Objekt

C#-Klasse und -Objekt

In diesem Tutorial lernen Sie anhand von Beispielen das Konzept von Klassen und Objekten in C# kennen.

C# ist ein objektorientiertes Programm. Bei der objektorientierten Programmierung (OOP) lösen wir komplexe Probleme, indem wir sie in Objekte aufteilen.

Um mit Objekten zu arbeiten, müssen wir die folgenden Aktivitäten ausführen:

• Klasse erstellen
• Objekte aus der Klasse erstellen

---

C#-Klasse

Bevor wir etwas über Objekte lernen, müssen wir die Funktionsweise von Klassen verstehen. Klasse ist die Blaupause für das Objekt.

Wir können uns die Klasse als Skizze (Prototyp) eines Hauses vorstellen . Darin sind alle Details zu Böden, Türen, Fenstern usw. enthalten. Anhand dieser Beschreibungen können wir ein Haus bauen. Haus ist das Objekt.

So wie viele Häuser aus der Skizze erstellt werden können, können wir viele Objekte aus einer Klasse erstellen.

Erstellen Sie eine Klasse in C#

Wir verwenden das Schlüsselwort class, um ein Objekt zu erstellen. Zum Beispiel

class ClassName {

}

Hier haben wir eine Klasse namens ClassName erstellt . Eine Klasse kann

enthalten

• Felder - Variablen zum Speichern von Daten
• Methoden - Funktionen zum Ausführen bestimmter Aufgaben

Sehen wir uns ein Beispiel an,

class Dog {
 
  //field
  string breed;
 
  //method
  public void bark() {

  }
 
}

Im obigen Beispiel

• Hund - Klassenname
• Rasse - Feld
• bellen() - Methode

Hinweis :In C# werden Felder und Methoden innerhalb einer Klasse als Mitglieder einer Klasse bezeichnet.

---

C#-Objekte

Ein Objekt ist eine Instanz einer Klasse. Angenommen, wir haben eine Klasse Hund . Bulldogge, Deutscher Schäferhund, Mops sind Objekte der Klasse.

Ein Objekt einer Klasse erstellen

In C# erstellen wir wie folgt ein Objekt der Klasse.

ClassName obj = new ClassName();

Hier haben wir den new verwendet Schlüsselwort, um ein Objekt der Klasse zu erstellen. Und obj ist der Name des Objekts. Lassen Sie uns nun ein Objekt aus dem Hund erstellen Klasse.

Dog bullDog = new Dog();

Nun, der bullDog Objekt kann auf die Felder und Methoden von Dog zugreifen Klasse.

---

Zugriff auf Klassenmitglieder mit Objekt

Wir verwenden den Namen von Objekten zusammen mit dem . Operator für den Zugriff auf Mitglieder einer Klasse. Zum Beispiel

using System;

namespace ClassObject {

  class Dog {
    string breed;

    public void bark() {
      Console.WriteLine("Bark Bark !!");
      
    }

    static void Main(string[] args) {

      // create Dog object 
      Dog bullDog = new Dog();

      // access breed of the Dog 
      bullDog.breed = "Bull Dog";
      Console.WriteLine(bullDog.breed);

      // access method of the Dog
      bullDog.bark();   

      Console.ReadLine();
     
    }
  }
}

Ausgabe

Bull Dog
Bark Bark !!

Im obigen Programm haben wir ein Objekt namens bullDog erstellt vom Hund Klasse. Beachten Sie, dass wir den Objektnamen und den . verwendet haben (Punktoperator), um auf die Rasse zuzugreifen Feld

// access breed of the Dog
bullDog.breed = "Bull Dog";

und die bark() Methode

// access method of the Dog
bullDog.bark();

---

Mehrere Objekte einer Klasse erstellen

Wir können mehrere Objekte aus derselben Klasse erstellen. Zum Beispiel

using System;

namespace ClassObject {

  class Employee {

    string department;

    static void Main(string[] args) {

      // create Employee object 
      Employee sheeran = new Employee();

      // set department for sheeran
      sheeran.department = "Development";
      Console.WriteLine("Sheeran: " + sheeran.department);

      // create second object of Employee
      Employee taylor = new Employee();

      // set department for taylor
      taylor.department = "Content Writing";
      Console.WriteLine("Taylor: " + taylor.department);

      Console.ReadLine();
    }
  }
}

Ausgabe

Sheeran: Development
Taylor: Content Writing

Im obigen Beispiel haben wir zwei Objekte erstellt:sheeran und Taylor vom Mitarbeiter Klasse.

Hier können Sie sehen, dass beide Objekte ihre eigene Version der Abteilung haben Feld mit unterschiedlichen Werten.

---

Objekte in einer anderen Klasse erstellen

In C# können wir auch ein Objekt einer Klasse in einer anderen Klasse erstellen. Zum Beispiel

Zum Beispiel

using System;

namespace ClassObject {

  class Employee {
    public string name;

    public void work(string work) {
      Console.WriteLine("Work: " + work);
      
    }
  }

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

      // create Employee object 
      Employee e1= new Employee();

      Console.WriteLine("Employee 1");

      // set name of the Employee 
      e1.name="Gloria";
      Console.WriteLine("Name: " + e1.name);

      //call method of the Employee
      e1.work("Coding"); 

      Console.ReadLine();
     
    }
  }
}

Ausgabe

Employee 1
Name: Gloria
Work: Coding

Im obigen Beispiel haben wir zwei Klassen:Employee und EmployeeDrive . Hier erstellen wir ein Objekt e1 des Mitarbeiters Klasse im EmployeeDrive Klasse.

Wir haben die e1 verwendet -Objekt, um auf die Mitglieder des Employee zuzugreifen Klasse von EmployeeDrive . Dies ist möglich, weil die Mitglieder in der Employee Klasse sind public .

Hier, public ist ein Zugriffsbezeichner, der bedeutet, dass die Klassenmitglieder von allen anderen Klassen aus zugänglich sind. Weitere Informationen finden Sie unter C#-Zugriffsmodifikatoren.

---

Warum Objekte und Klassen?

Objekte und Klassen helfen uns, ein großes Projekt in kleinere Teilprobleme zu unterteilen.

Angenommen, Sie möchten ein Spiel mit Hunderten von Feinden erstellen, von denen jeder Felder wie Gesundheit hat , Munition und Methoden wie shoot() und run() .

Mit OOP können wir einen einzelnen Feind erstellen Klasse mit erforderlichen Feldern und Methoden. Dann können wir daraus mehrere feindliche Objekte erstellen.

Jedes der feindlichen Objekte hat seine eigene Version von Gesundheit und Munition Felder. Und sie können das gemeinsame shoot() verwenden und run() Methoden.

Anstatt an Projekte in Bezug auf Variablen und Methoden zu denken, können wir sie jetzt in Bezug auf Objekte betrachten.

Dies hilft, die Komplexität zu verwalten und unseren Code wiederverwendbar zu machen.