Der Java-Compiler vergibt jeder Methode eine eigene eindeutige Signatur. Dadurch ist es erlaubt innerhalb einer Klasse den gleichen Methodennamen für unterschiedliche Methoden zu verwenden.
Die Signatur der Methoden setzt sich aus dem nach außen sichtbaren Methodennamen und einer codierten Information über die Parameterliste der Methode zusammen. Die codierte Information über die Parameterliste enthält Angaben über die Datentypen der Methodenparameter und die Reihenfolge der Parameter.
Somit bekommt jede Methode in Java einen eigenen internen Namen zugewiesen. Dieser interne Methodenname muss immer eindeutig sein, daher sind Methoden mit gleichen äußeren Methodennamen und gleicher Parameterliste nicht erlaubt. Gleichnamige Methoden müssen sich also mindestens in einem Parameter unterscheiden.
Dieses Konzept, das mehrfache Verwenden des gleichen Methodennamens, wird als Überladen von Methoden bezeichnet.
Wann sollte man Methoden überladen?
Es ist immer dann empfehlenswert Methoden zu überladen, wenn die gleichnamigen Methoden nahezu identische Funktionen ausführen. Eine sinnvolle Anwendung für das Überladen von Methoden ist die Simulation von variablen Parameterlisten. In diesem Fall wäre die Funktionalität jeder gleichnamigen Methode identisch, die Methoden würden ihre Arbeit aber mit unterschiedlichen Parametern verrichten.
Hinweis: Methoden, die sich nur durch den Datentyp ihres Rückgabewerts unterscheiden, werden vom Java-Compiler als identisch angesehen. Der Compiler kann in einem solchen Fall nicht unterscheiden welche dieser gleichnamigen Methoden aufgerufen werden soll.
Mit dem folgenden Programmbeispiel wird das Überladen von Methoden noch einmal verdeutlicht. Die Methode mit dem äußeren Methodennamen berechneVerkaufspreis wird mehrfach überladen.
Beispielanwendung für das Überladen von Methoden
/*
* Beispielanwendung für das Überladen von Methoden
*/
public class Schaf{
// Deklaration der Instanzvariablen (Membervariablen, Instanzmerkmale)
public String name;
public byte alter;
public float wollMenge;
// Methode 1
public float berechneVerkaufspreis(int qmPreis)
{
return (wollMenge * qmPreis);
}
// Methode 2
public float berechneVerkaufspreis(int qmPreis, short rabatt)
{
float vollerPreis = berechneVerkaufspreis(qmPreis);
return (vollerPreis * (100-rabatt) / 100)+2;
}
// Methode 3
public float berechneVerkaufspreis(int qmPreis, byte rabatt)
{
return (berechneVerkaufspreis(qmPreis) * (100-rabatt) / 100)+3;
}
// Methode 4
public float berechneVerkaufspreis(byte rabatt, int qmPreis)
{
return (wollMenge * qmPreis * (100-rabatt) / 100)+4;
}
// main-Methode
public static void main(String[] args) {
// Deklaration und Initialisierung der Objektvariable schafObjekt
Schaf schafObjekt = new Schaf();
// Deklaration und Initialisierung der primitiven Variablen
int preisfaktor = 15;
byte rabattByte = 30;
short rabattShort = 30;
float preis;
// Den Instanzvariablen werden Werte zugewiesen (Schreibzugriff)
schafObjekt.name = "Othello";
schafObjekt.alter = 7;
schafObjekt.wollMenge = 2.153f;
// Ausgabe der Inhalte der Instanzvariablen (Lesezugriff)
System.out.println("\nName : " + schafObjekt.name);
System.out.println("Alter : " + schafObjekt.alter + " Jahre");
System.out.println("Wollmenge : " + schafObjekt.wollMenge + " m^2");
// Methodenaufruf und Ausgabe der berechneten Verkaufspreise
preis = schafObjekt.berechneVerkaufspreis(preisfaktor);
System.out.println("\n[Methode 1] - Preis: " + preis + " Euro");
preis = schafObjekt.berechneVerkaufspreis(preisfaktor, rabattShort);
System.out.println("[Methode 2] - Preis: " + preis + " Euro");
preis = schafObjekt.berechneVerkaufspreis(preisfaktor, rabattByte);
System.out.println("[Methode 3] - Preis: " + preis + " Euro");
preis = schafObjekt.berechneVerkaufspreis(rabattByte, preisfaktor);
System.out.println("[Methode 4] - Preis: " + preis + " Euro");
}
}
Zunächst werden die Instanzvariablen name, alter und wollMenge deklariert. Anschließend werden vier Methoden berechneVerkaufspreis und die main-Methode definiert.
Die vier Methoden berechneVerkaufspreis werden überladen. Sie besitzen alle den gleichen äußeren Methodennamen, aber unterschiedliche Parameterlisten. In der Methode main wird zu Beginn die Variablendeklaration und -initialisierung durchgeführt. Anschließend werden die Instanzmerkmale der Instanz schafObjekt gesetzt und auf dem Bildschirm ausgegeben.
Aufrufen der überladenen Methoden
Der Aufruf der vier überladenen Methoden berechneVerkaufspreis erfolgt am Ende der main-Methode. Als erstes wird die Methode berechneVerkaufspreis mit einem Parameter [Methode 1] aufgerufen. Der zurückgelieferte Rückgabewert wird anschließend auf der Kommandozeile ausgegeben.
Dann wird die Methode berechneVerkaufspreis mit der Parameterliste (int, short) aufgerufen [Methode 2].
Bitte darauf achten, dass in der Methode 2 die Methode 1 zur Berechnung genutzt wird. Zur besseren Unterscheidung wird dem berechneten Verkaufspreis die Zahl 2 hinzu addiert.
Als dritte Methode wird berechneVerkaufspreis mit der Parameterliste (int, byte) aufgerufen [Methode 3]. Auch in der Methode 3 wird Methode 1 aufgerufen. Zur besseren Unterscheidung wird dem berechneten Verkaufspreis die Zahl 3 hinzu addiert.
Am Ende wird die Methode berechneVerkaufspreis mit der Parameterliste (byte, int) aufgerufen [Methode 4]. Zur besseren Unterscheidung wird dem berechneten Verkaufspreis die Zahl 4 hinzu addiert.
Wie unterscheidet der Java-Compiler die gleichnamigen Methoden
Der Java-Compiler unterscheidet die vier Methoden berechneVerkaufspreis über ihren internen Methodennamen (Signatur aus Name und Parameterliste). Es wird dabei, neben dem Datentyp der Methodenparameter, sogar auf die Reihenfolge der Parameter geachtet.
Der Compiler kann Methode 1 von den anderen Methoden aufgrund der unterschiedlichen Anzahl der Methodenparameter (1 Parameter gegenüber 2 Parametern) unterscheiden.
Der Compiler kann Methode 2 von Methode 3 aufgrund der unterschiedlichen Datentypen der Methodenparameter (int, short gegenüber int, byte) unterscheiden.
Der Compiler kann Methode 3 von Methode 4 aufgrund der unterschiedlichen Reihenfolge der Methodenparameter (int, byte gegenüber byte, int) unterscheiden.
In der folgenden Abbildung ist die Kommandozeilenausgabe der Beispielanwendung darstellt:
Java Überladen von Methoden – Ausgabe der Beispielanwendung
Comments 1
Pingback: Klassen in Java: Die Grundlagen der objektorientierten Programmierung