Lernhilfe OOP Basics

Begriffe

Wir unterscheiden in der objektorientierten Programmierung zwischen Klassen und Objekten. Objekte werden oft auch Instanzen oder Objektinstanzen genannt, meinen aber dasselbe.

Klassen

sind unsere Baupläne oder Blaupausen. Wir schreiben eine Klasse um zu definieren was denn enthalten ist, wenn eine neue Objektinstanz erstellt wird.

Klassen können Konstruktoren, Properties und Methoden enthalten.

public class Song
{
  // ...
}

Properties

Das sind die Eigenschaften die ein Objekt hat, wenn später von der Klasse eine Instanz erstellt wird. Sie sind sehr ähnlich zu Variablen, jedoch unterscheidet sich die Syntax, also die Schreibweise mit der Properties definiert werden zu denen von Variablen. Außerdem ist der Speicherbereich ein anderer. Variablen existieren in dem Block bzw. Scope in dem sie erstellt wurden. Properties sind mit einer Objektinstanz verbunden und existieren solange, solange auch das Objekt existiert zu dem sie gehören.

public class Song
{
  // Properties
  public string Title { get; set; }
  public int Duration { get; set; }
}

Konstruktoren

Diese sind ähnlich wie Methoden. Sie enthalten Anweisungen (Statements) die ausgeführt werden immer wenn eine neue Objektinstanz erstellt wird um genau diese Instanz zu initialisieren. Initialisieren meint, dass das Objekt für die Verwendung vorbereitet wird. Meistens werden dabei Werte von Properties gesetzt.

Im Unterschied zu Methoden, haben Konstruktoren keinen Rückgabewert. Wenn kein Konstruktor angegeben wird, wird automatisch ein Konstruktor ohne Parameter generiert. Sobald mindestens ein Konstruktor selbst angegeben wurde, wird dieser parameterlose Konstruktor nicht mehr automatisch generiert.

Konstruktoren müssen immer genauso wie die Klasse heißen.

public class Song
{
  // Properties
  public string Title { get; set; }
  public int Duration { get; set; }

  // Konstruktor
  public Song() {
    // Initialisierung
    this.Title = "Unbekannt";
    this.Duration = 0;
  }
}

Konstruktorenverkettung

Es können auch mehrere Konstruktoren definiert werden, die aufeinander aufbauen. So kann ein Konstruktor zu einem anderen Konstruktor weiterleiten und Parameter übergeben. Dieser könnte dann wieder an einen anderen Konstruktor weiterleiten usw.

public class Song
{
  // Properties
  public string Title { get; set; }
  public int Duration { get; set; }

  // Konstruktor ohne Parameter.
  // Nutzt Konstruktorverkettung um einen anderen Konstruktor mit zwei Parameter aufzurufen.
  public Song() : this("Unbekannt", 0) {
  }

  // Konstruktor mit 2 Parameter
  public Song(string title, int duration) {
    this.Title = title;
    this.Duration = duration;
  }
}

Methoden

Methoden bilden das Verhalten von Objekten ab. Es sind Aktionen, die das Objekt ausführen kann.

public class Song
{
  // Properties
  public string Title { get; set; }
  public int Duration { get; set; }
  public int Ranking { get; set; }

  public void PrintInfo()
  {
    Console.WriteLine($"Titel: {this.Title}");
    Console.WriteLine($"Dauer: {this.Duration}");
    string greatSong = "nein";
    if (this.Ranking > 10)
    {
      greatSong = "ja";
    }
    Console.WriteLine($"Ist das ein großartiger Song? {greatSong}");
  }

  public string GetSummary()
  {
    return $"{Title} - {Duration}";
  }
}

Objekterstellung

Um eine Klasse verwenden zu Können muss zuerst ein Objekt erstellt werden. Dazu benötigen wir 2 Dinge. Zuerst brauchen wir eine Variable in der wir das neu erstellte Objekt abspeichern können. Klassennamen können wie Namen von anderen Datentypen verwendet werden. Das heißt als Datentyp für das Objekt wird der Name der Klasse verwendet.

// Variable mit Datentyp Song
// Diese Variable kann ein Objekt der Klasse Song aufnehmen.
// Nur durch die Definition der Variable wird noch kein Objekt erstellt.
Song mySong;

Als nächstes müssen wir ein Objekt erzeugen. Das erzeugte Objekt kann dann der Variable zugewiesen werden. Zum Erzeugen verwenden wir das Schlüsselwort new. Danach kommt der Name der Klasse gefolgt von runden Klammern.

Song mySong;

// Hier erstellen wir ein neues Objekt und weisen es der Variable zu.
mySong = new Song();

// Natürlich kann die Variablendefinition und Objektinstanzierung in der gleichen Zeile erfolgen;
Song mySong2 = new Song();

// Und es können beliebig viele Objekte der Klasse Song erstellt werden.
Song mySong3 = new Song();
Song mySong4 = new Song();

Bei der Erstellung eines neuen Objekts muss darauf geachtet werden, dass die richtigen Parameter für den Konstruktor übergeben werden.

public class Artist
{
  // kein Konstruktor
}


public class Song
{
  public Song(string title) {
    // ...
  }
}

// Die Klasse Artist hat keinen Konstruktor definiert.
// Wie wir wissen wird dann immer automatisch ein parameterloser Konstruktor definiert.
// Ein neues Objekt kann angelegt werden in dem dieser parameterlose Konstruktor aufgerufen wird.
Artist a = new Artist(); // funktioniert

// Da aber sonst keine Konstruktoren definiert sind,
// kann natürlich auch kein Konstruktor mit mehreren Parameter aufgerufen werden.
Artist a1 = new Artist("Queen"); // funktioniert nicht,
                                 //da es keinen Konstruktor mit einem string Parameter gibt

// Die Klasse Song hingegen hat einen Konstruktor mit einem string Parameter.
// Sobald selbst ein Konstruktor definiert wurde, wird der parameterlose Konstruktor nicht mehr automatisch generiert.
Song s = new Song(); // funktioniert nicht

// Es muss beim Erstellen des Objekts dann einer der Konstruktoren verwendet werden, die in der Klasse definiert wurden.
Song s1 = new Song("Bohemian Rhapsody"); // funktioniert

Objektverwendung

Wenn ein Objekt erstellt wurde kann es verwendet werden. Zum Beispiel können Werte von Properties ausgelesen und verändert werden, oder Methoden aufgerufen werden.

Song s = new Song();

// Properties auslesen und Werte ändern.
Console.WriteLine($"Titel des Songs: {s.Title}");
s.Duration = 180;

// Methodenaufrufe
s.PrintInfo();

// Methoden können Rückgabewerte haben. Diese können weiter verwendet werden.
string summary = s.GetSummary();
Console.WriteLine(summary);

ToString

Die Methode ToString() ist eine besondere Methode. Wenn sie aufgerufen wird wird eine Repräsentation des Objekts als Zeichenkette (String) ausgegeben. Die Methode ToString() ist in jedem Objekt vorhanden. Wenn die Methode nicht selbst implementiert wird, wird Standardmäßig der Name der Klasse ausgegeben.

public class Song
{

}

Song song = new Song();
string songString = song.ToString();
Console.WriteLine(songString); // Ausgabe: "Song"

Die Methode ToString() kann selbst implementiert werden um eine andere Repräsentation zu erstellen. Dabei muss das Schlüsselwort override verwendet werden.

public class Song
{
  public string Title { get; set; }

  public Song(string title) {
    this.Title = title;
  }

  public override string ToString()
  {
    return $"Song: {this.Title}";
  }
}

Song song = new Song("Bohemian Rhapsody");
string songString = song.ToString();
Console.WriteLine(songString); // Ausgabe: "Song: Bohemian Rhapsody"

Es ist außerdem nicht immer nötig die Methode ToString() aufzurufen wenn ein Objekt mit Console.WriteLine ausgegeben werden soll. Man kann bei Console.WriteLine auch direkt das auszugebene Objekt angaben. Dann wird im Hintergrund automatisch die ToString() Methode ausgeführt.

public class Song
{
  public string Title { get; set; }

  public Song(string title) {
    this.Title = title;
  }

  public override string ToString()
  {
    return $"Song: {this.Title}";
  }
}

Song song = new Song("Bohemian Rhapsody");
Console.WriteLine(song); // Ausgabe: "Song: Bohemian Rhapsody"

Klassen sind Datentypen

Wie bereits erklärt sind Klassen wie Datentypen zu verwenden. Wir können Variablen definieren und wir können sie natürlich auch als Rückgabewerte von Methoden verwenden.

public class Theater
{
  public Ticket BuyTicket()
  {
    return new Ticket();
  }
}

Theater theater = new Theater();
Ticket ticket = theater.BuyTicket();