C# Overloading vs Override: Der Unterschied einfach erklärt

Stell dir vor, du sitzt in deiner ersten Woche als Junior-Entwickler. Dein Teamleiter erklärt dir die Codebasis und verwendet dabei Begriffe wie „Methodenüberladung" und „Überschreiben". Du nickst zustimmend, aber innerlich fragst du dich: Was ist eigentlich der Unterschied zwischen C# Overloading Override?

Genau das schauen wir uns jetzt an. Egal, ob du Fachinformatiker-Azubi, IT-Student oder Berufseinsteiger bist - diese beiden Konzepte gehören zu den Grundlagen der objektorientierten Programmierung (OOP). Sobald du den Unterschied einmal verstanden hast, wird dein Code deutlich sauberer und flexibler. Wir klären, wann du welches Verfahren nutzt und worin die technischen Unterschiede liegen.

Was ist Method Overloading?

Method Overloading (Überladen) bedeutet: Du definierst mehrere Methoden mit demselben Namen in derselben Klasse. Jede dieser Methoden hat aber eine unterschiedliche Parameterliste (also andere oder zusätzliche Eingabewerte).

Der entscheidende Punkt ist hierbei die sogenannte Signatur. Sie setzt sich aus dem Methodennamen und der Anzahl sowie dem Datentyp der Parameter zusammen. Der Rückgabetyp (z. B. `void` oder `int`) spielt für das Overloading keine Rolle.

Stell dir vor, du hast einen Taschenrechner. Der kann addieren - egal, ob du zwei Zahlen oder drei Zahlen übergibst. Du möchtest nicht für jeden Fall eine neue Methode `AddiereMitDreiZahlen` schreiben. Stattdessen nutzt du denselben Methodennamen und C# entscheidet anhand der Parameter automatisch, welche Version gemeint ist.

public class Taschenrechner
{
  // Version 1: Zwei ganze Zahlen addieren
  public int Addiere(int a, int b)
  {
    return a + b;
  }

  // Version 2: Drei ganze Zahlen addieren
  public int Addiere(int a, int b, int c)
  {
    return a + b + c;
  }

  // Version 3: Zwei Kommazahlen addieren
  public double Addiere(double a, double b)
  {
    return a + b;
  }
}

Welche Methode aufgerufen wird, entscheidet der Compiler bereits zur Compile-Zeit (also während du den Code baust). Das nennt man auch Compile-Time Polymorphism oder frühe Bindung.

Wichtig: Overloading findet innerhalb derselben Klasse statt. Der Methodenname bleibt gleich, aber die Parameterliste muss sich unterscheiden.

Was ist Method Overriding?

Method Overriding (Überschreiben) bedeutet: Eine Kind-Klasse (abgeleitete Klasse) ersetzt die Implementierung einer Methode, die sie von ihrer Eltern-Klasse geerbt hat. Die Methode hat dabei denselben Namen und dieselbe Parameterliste.

Warum braucht man das? Stell dir vor, du hast eine Basisklasse `Tier`. Davon erben die Klassen `Hund` und `Katze`. Jedes Tier hat eine Methode `MacheGeraeusch()`. Aber ein Hund bellt und eine Katze miaut. Du überschreibst also die allgemeine Methode in jeder Kind-Klasse mit einer spezifischen Implementierung.

public class Tier
{
  // virtual erlaubt das Überschreiben in abgeleiteten Klassen
  public virtual void MacheGeraeusch()
  {
    Console.WriteLine("Das Tier macht ein Geraeusch.");
  }
}

public class Hund : Tier
{
  // override ueberschreibt die Methode der Basisklasse
  public override void MacheGeraeusch()
  {
    Console.WriteLine("Der Hund bellt: Wuff!");
  }
}

public class Katze : Tier
{
  public override void MacheGeraeusch()
  {
    Console.WriteLine("Die Katze miaut: Miau!");
  }
}

Damit du eine Methode überschreiben kannst, muss sie in der Basisklasse mit `virtual` markiert sein. In der Kindklasse nutzt du dann das Schlüsselwort `override`.

Welche Methode tatsächlich ausgeführt wird, entscheidet C# erst zur Laufzeit - also während das Programm läuft. Das nennt man Run-Time Polymorphism oder späte Bindung. Mehr zu diesen Mechanismen findest du auch in den offiziellen C# Docs von Microsoft.

Wichtig: Overriding findet zwischen Basis- und Kindklasse statt. Name und Parameterliste bleiben identisch, die Implementierung ändert sich.

Was ist der Unterschied zwischen Overloading und Overriding?

Hier siehst du die wichtigsten Unterschiede auf einen Blick. Diese Tabelle hilft dir, die Konzepte schnell zuzuordnen, wenn du Code prüfst oder schreibst.

Wie sieht das in der Praxis aus?

Hier ist ein umfassendes Beispiel, das beide Konzepte kombiniert. Es ist bewusst einfach gehalten, damit du es in Visual Studio oder direkt im Browser (z. B. auf dotnetfiddle.net) nachvollziehen kannst.

Wir bauen ein kleines Log-System. Es soll Nachrichten auf verschiedene Arten protokollieren können (Overloading) und das Verhalten anpassen, wenn wir spezielle Logger-Typen verwenden (Overriding).

using System;
using System.Collections.Generic;

// Basisklasse fuer alle Logger
public class Logger
{
  // Overloading: Drei Methoden mit demselben Namen, aber unterschiedlichen Parametern
  public void Logge(string nachricht)
  {
    Console.WriteLine($"[INFO] {nachricht}");
  }

  public void Logge(string nachricht, string level)
  {
    Console.WriteLine($"[{level}] {nachricht}");
  }

  public void Logge(string nachricht, Exception fehler)
  {
    Console.WriteLine($"[FEHLER] {nachricht} - {fehler.Message}");
  }

  // virtual erlaubt Kindklassen das Ueberschreiben
  public virtual void ZeigeFormat()
  {
    Console.WriteLine("Standard-Format: Text-Konsole");
  }
}

// Kindklasse: Schreibt Logs in eine Datei
public class DateiLogger : Logger
{
  // Override: Dieselbe Methode, aber anderes Verhalten
  public override void ZeigeFormat()
  {
    Console.WriteLine("Datei-Format: Schreibt in .log-Datei");
  }
}

public class Programm
{
  public static void Main()
  {
    Logger standardLogger = new Logger();
    DateiLogger dateiLogger = new DateiLogger();

    // Overloading in Aktion: Drei verschiedene Parameter-Setups
    standardLogger.Logge("Server gestartet");
    standardLogger.Logge("Wenig Speicherplatz", "WARNUNG");
    standardLogger.Logge("Verbindung abgebrochen", new Exception("Timeout"));

    // Overriding in Aktion: Kindklasse aendert das Verhalten
    standardLogger.ZeigeFormat();    // Ausgabe: Standard-Format
    dateiLogger.ZeigeFormat();       // Ausgabe: Datei-Format

    // Polymorphie: Basistyp-Referenz, aber Kindklassen-Verhalten
    Logger polyLogger = new DateiLogger();
    polyLogger.ZeigeFormat();        // Ausgabe: Datei-Format
  }
}

Fällt dir der letzte Block in der `Main`-Methode auf? Obwohl `polyLogger` vom Typ `Logger` (Basisklasse) ist, wird die Methode aus `DateiLogger` (Kindklasse) ausgeführt. Das ist genau die Stärke von Overriding - das Objekt entscheidet dynamisch, was es tun soll.

Welche Fallstricke gibt es?

Auch wenn die Konzepte logisch sind, passieren gerade am Anfang Fehler. Hier sind die drei häufigsten Stolpersteine.

Fehler 1: `override` ohne `virtual`

// FALSCH: Basisklasse ohne virtual
public class Tier
{
  public void MacheGeraeusch() { }  // fehlt: virtual
}

public class Hund : Tier
{
  public override void MacheGeraeusch() { }  // Compiler-Fehler!
}

Warum? C# ist eine typsichere Sprache. Es verlangt explizit die Erlaubnis (`virtual`), damit eine Kindklasse eine Methode außer Kraft setzen darf. Ohne dieses Schlüsselwort bekommst du eine Fehlermeldung beim Kompilieren.

Fehler 2: Overloading über den Rückgabewert versuchen

// FALSCH: Nur der Rueckgabetyp aendert sich - das ist KEIN Overloading
public int Berechne(int x)
{
  return x + 1;
}

public double Berechne(int x)  // Compiler-Fehler!
{
  return x + 1.0;
}

Der Rückgabetyp ist kein Teil der Signatur. Der Compiler kann nicht unterscheiden, welche Methode du meinst, wenn du nur `Berechne(5)` aufrufst. Du musst die Parameterliste (Anzahl oder Typ der Argumente) ändern.

Fehler 3: `new` statt `override` verwenden

public class Tier
{
  public virtual void BewegeDich() { }
}

public class Hund : Tier
{
  // Das ist Method Hiding, KEIN Overriding!
  public new void BewegeDich() { }
}

Mit `new` versteckst du die Methode der Basisklasse nur. Das ist technisch möglich, aber oft ein Fehler. Wenn du Polymorphie nutzt (also `Tier t = new Hund();`), wird trotzdem die Basis-Methode aufgerufen. Das führt zu schwer auffindbaren Bugs, da das Verhalten je nach Referenztyp variiert.

FAQ: Häufige Fragen zu C# Overloading Override

Kann ich eine Methode gleichzeitig überladen und überschreiben?

Ja, das ist möglich und oft sehr nützlich. Du kannst in der Basisklasse eine `virtual`-Methode definieren und diese in der Kindklasse mit `override` überschreiben. Gleichzeitig kannst du in der Basisklasse (oder auch in der Kindklasse) weitere überladene Versionen mit anderen Parametern anlegen.

Was passiert, wenn ich eine Methode überladen will, aber die Parameter nur umbenenne?

Das funktioniert nicht. Allein die Namen der Parameter sind irrelevant. Nur die Datentypen und die Reihenfolge der Parameter zählen zur Unterscheidung. `Addiere(int a, int b)` und `Addiere(int x, int y)` sind für den Compiler dieselbe Methode.

Wann nutze ich `virtual` und wann `abstract`?

Verwende `virtual`, wenn du eine Standard-Implementierung hast, die für die meisten Fälle passt, aber Kindklassen die Option geben möchtest, sie anzupassen. Nutze `abstract`, wenn es keine sinnvolle Standard-Implementierung gibt und zwingend jede Kindklasse ihre eigene Version liefern muss (dann muss auch die Klasse selbst `abstract` sein).

Funktioniert Overriding auch ohne Vererbung?

Nein, absolut nicht. Overriding setzt zwingend eine Vererbungsbeziehung (Inheritance) voraus. Ohne die Kette von Basisklasse zu Kindklasse gibt es nichts zu überschreiben. Wenn du Methoden in zwei völlig unabhängigen Klassen gleich benennst, ist das einfach nur Zufall und technisch bedeutungslos.

Fazit

Overloading und Overriding klingen im Englischen ähnlich und werden oft verwechselt. Doch ihr Einsatz in der OOP ist völlig unterschiedlich:

• Overloading: Du nutzt es für Bequemlichkeit innerhalb einer Klasse. Ein Methodenname für verschiedene Eingabewarianten (z. B. `Addiere(int, int)` vs. `Addiere(double, double)`).

• Overriding: Du nutzt es für Anpassung in der Vererbung. Eine Kindklasse spezialisiert das Verhalten der Elternklasse (z. B. `Hund` macht einen anderen Laut als das allgemeine `Tier`).

Wenn du diese Unterschiede verstanden hast, beherrschst du einen zentralen Teil der objektorientierten Programmierung in C#. Dein Code wird nicht nur funktionieren, sondern auch architektonisch sauberer und erweiterbarer sein.

Wenn du bei C#, Java oder anderen IT-Themen Unterstützung brauchst - ob für die IHK-Abschlussprüfung, die Uni-Klausur oder den Berufseinstieg - schau dir an, wie study-it.education dir mit gezielter Nachhilfe helfen kann.