Einführung
Überschreiben und Überladen sind die Kernkonzepte der Java-Programmierung. Sie sind die Möglichkeiten, Polymorphismus in unseren Java-Programmen zu implementieren. Polymorphismus ist eines der OOPS-Konzepte.
Wenn die Methodensignatur (Name und Parameter) in der Superklasse und der Kindklasse gleich sind, wird es als Überschreiben bezeichnet. Wenn zwei oder mehr Methoden in derselben Klasse denselben Namen, aber unterschiedliche Parameter haben, wird es als Überladen bezeichnet.
Vergleich von Überschreiben und Überladen
| Overriding | Overloading |
|---|---|
| Implements “runtime polymorphism” | Implements “compile time polymorphism” |
| The method call is determined at runtime based on the object type | The method call is determined at compile time |
| Occurs between superclass and subclass | Occurs between the methods in the same class |
| Have the same signature (name and method arguments) | Have the same name, but the parameters are different |
| On error, the effect will be visible at runtime | On error, it can be caught at compile time |
Beispiel für Überschreiben und Überladen
Hier ist ein Beispiel für Überladen und Überschreiben in einem Java-Programm:
package com.journaldev.examples;
import java.util.Arrays;
public class Processor {
public void process(int i, int j) {
System.out.printf("Processing two integers:%d, %d", i, j);
}
public void process(int[] ints) {
System.out.println("Adding integer array:" + Arrays.toString(ints));
}
public void process(Object[] objs) {
System.out.println("Adding integer array:" + Arrays.toString(objs));
}
}
class MathProcessor extends Processor {
@Override
public void process(int i, int j) {
System.out.println("Sum of integers is " + (i + j));
}
@Override
public void process(int[] ints) {
int sum = 0;
for (int i : ints) {
sum += i;
}
System.out.println("Sum of integer array elements is " + sum);
}
}
Überschreiben
Die Methode process() und die Parameter int i, int j in Processor werden in der Unterklasse MathProcessor überschrieben. Zeile 7 und Zeile 23:
public class Processor {
public void process(int i, int j) { /* ... */ }
}
/* ... */
class MathProcessor extends Processor {
@Override
public void process(int i, int j) { /* ... */ }
}
Und die Methode process() und int[] ints in Processor werden auch in der Unterklasse überschrieben. Zeile 11 und Zeile 28:
public class Processor {
public void process(int[] ints) { /* ... */ }
}
/* ... */
class MathProcessor extends Processor {
@Override
public void process(Object[] objs) { /* ... */ }
}
Überladen
Die Methode process() wird in der Klasse Processor überladen. Zeilen 7, 11 und 15:
public class Processor {
public void process(int i, int j) { /* ... */ }
public void process(int[] ints) { /* ... */ }
public void process(Object[] objs) { /* ... */ }
}
Schlussfolgerung
Im diesem Artikel haben wir das Überschreiben und Überladen in Java behandelt. Das Überschreiben tritt auf, wenn die Methodensignatur in der Oberklasse und der Unterklassenklasse gleich ist. Das Überladen tritt auf, wenn zwei oder mehr Methoden in derselben Klasse denselben Namen, aber unterschiedliche Parameter haben.
Source:
https://www.digitalocean.com/community/tutorials/overriding-vs-overloading-in-java