Wie unterscheiden sich Methodenüberschreibung und Methodenüberladung in Java?

Unterscheidung von dynamischem und statischem Polymorphismus in Java

Das Verständnis des Unterschieds zwischen dynamischem und statischem Polymorphismus ist bei der objektorientierten Programmierung mit Java von entscheidender Bedeutung. Dieser Artikel bietet eine vereinfachte Erklärung und ein Beispiel zur Veranschaulichung dieses Konzepts.

Dynamischer vs. statischer Polymorphismus

Polymorphismus ermöglicht, dass ein einzelner Methodenname je nach dem mehrere Implementierungen haben kann Objekttyp, der es aufruft. Es gibt zwei Haupttypen von Polymorphismus:

• Dynamischer Polymorphismus (Laufzeitbindung): Methodenaufrufe werden zur Laufzeit basierend auf der Klasse des tatsächlichen Objekts aufgelöst. Es tritt beim Überschreiben von Methoden in Unterklassen auf und wird auch als späte Bindung bezeichnet.
• Statischer Polymorphismus (Bindung zur Kompilierungszeit): Methodenaufrufe werden zur Kompilierungszeit basierend auf dem deklarierten Typ von aufgelöst die Referenzvariable. Es tritt bei Methodenüberladung in derselben Klasse auf und wird auch als frühe Bindung bezeichnet.

Methodenüberladung

Methodenüberladung ist eine Form des statischen Polymorphismus mit mehreren Methoden mit demselben Namen existieren in derselben Klasse, unterscheiden sich jedoch in ihren Parametern. Beim Aufrufen einer überladenen Methode bestimmt Java anhand der Anzahl und Art der übergebenen Argumente, welche Methode aufgerufen werden soll.

Codebeispiel (Methodenüberladung):

<code class="java">class Calculation {
  void sum(int a, int b) { System.out.println(a + b); }
  void sum(int a, int b, int c) { System.out.println(a + b + c); }

  public static void main(String[] args) {
    Calculation obj = new Calculation();
    obj.sum(10, 10, 10); // Output: 30
    obj.sum(20, 20); // Output: 40
  }
}</code>

Methodenüberschreibung

Methodenüberschreibung ist eine Form des dynamischen Polymorphismus, bei der Methoden mit demselben Namen und derselben Signatur in verschiedenen Klassen deklariert werden, aber eine gemeinsame übergeordnete Klasse haben. Beim Aufrufen einer überschriebenen Methode bestimmt Java die aufzurufende Methode basierend auf der tatsächlichen Klasse des Objekts zur Laufzeit.

Codebeispiel (Methodenüberschreibung):

<code class="java">class Animal {
  public void move() {
    System.out.println("Animals can move");
  }
}

class Dog extends Animal {

  public void move() {
    System.out.println("Dogs can walk and run");
  }
}

public class TestDog {

  public static void main(String[] args) {
    Animal a = new Animal(); // Animal reference and object
    Animal b = new Dog(); // Animal reference but Dog object

    a.move(); // Output: Animals can move

    b.move(); // Output: Dogs can walk and run
  }
}</code>

Das obige ist der detaillierte Inhalt vonWie unterscheiden sich Methodenüberschreibung und Methodenüberladung in Java?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!