So nutzt du Java Methoden mit variabler Argumentenanzahl bzw. VarArgs

Schlagwörter: Java Methoden, Java Programmierung

Du kennst das noch.
Kopfrechnen und zwar auf Zeit.

So etwas ist das Standardprogramm in den Schulklassen 1 bis 5.
Irgendwann, in Klasse 6 oder 7, kommt der Taschenrechner ins Spiel und Kopfrechnen ist aus dem Schulalltag gestrichen.

Schade eigentlich.
Dabei kann man diese Disziplin auch wunderbar in kleinen Spielen unterbringen.
Ich erinnere mich noch:
Meine Klasse und ich spielten öfters Bankrutschen.

Und der Erste, welcher die Lösung hatte – durfte eine Bank weiter rutschen.

Das gleiche Spiel beginnt von vorn.
Jetzt duelliert sich der Spieler von der ersten Bank mit zwei Spielern der nächsten Bank.

Also stellt der Lehrer(in) die nächste Matheaufgabe und derjenige mit der schnellsten richtigen Lösung rutscht zur nächsten Schulbank weiter.

Dieses Spiel geht immer so weiter.
Wenn man an der letzten Bank angekommen ist, geht der Sieger wieder zur ersten Bank zurück und misst sich mit dem ersten Spieler erneut.

Nach einer unterhaltsamen Unterrichtsstunde ist der Spaß vorbei und es wird gezählt, welcher Spieler – die meisten Bänke erobern konnte.
Und dieser gewinnt das Gesamtspiel.

In den ersten Klassen waren es recht leichte Aufgaben.
2+4 und Ähnliche.

Später wurden daraus Kettenaufgaben.
Also so etwas: 2+4+6+9+8
Und das nach wie vor auf Zeit.
Da musste man schon seine grauen Zellen richtig beanspruchen.

Nun ja – muss jeder selbst wissen.
Darum soll es auch nicht gehen.

Es geht in diesem Beitrag um Kettenaufgaben.
Und zwar um Java Methoden, welche Kettenaufgaben lösen können.

Im Klartext heißt dies:
Java Methoden mit variablen Argumentenlisten , kurzum VarArgs.

Beginnen wir mit einer gewöhnlichen Additionsmethode.

So wie diese hier:

public class JavaVarArgsDemo {
	
	//Methode mit zwei Parametern i und j
	static void addiere(int i, int j) {
		int ergebnis = i + j;//Addition wird in Variable ergebnis gespeichert
		System.out.println(ergebnis);//Konsolenausgabe
	}

	
	public static void main(String[] args) {
		addiere(2, 4); //Methodenaufruf mit zwei Argumenten (2 & 4) für die Parameter
	}
}

Die Methode „addiere()“ erwartet zwei Parameter „i“ und „j“.
In der main-Methode kannst du diese statische Methode aufrufen und übergibst dieser zwei Argumente.
Zum Beispiel 2 und 4.

Somit sind die beiden Platzhalter „i“ und „j“ belegt und der Methodenrumpf würde ausgeführt werden.

Also dann….
Wenn du jetzt auf „Run“ klickst, zeigt dir die Konsole das Ergebnis „6“ an.
Cool, oder?

Aber….

Falls diese Java Methode mit drei Zahlen rechnen soll….

Dann schiebst du einfach einen Parameter in der Parameterliste nach.
Außerdem musst du noch die Addition um den Summand „k“ erweitern.
Und schließlich übergibst du beispielsweise noch die „8“ als zusätzliches Argument.

public class JavaVarArgsDemo {
	
	//Methode mit drei Parametern i - j und k
	static void addiere(int i, int j, int k) {
		int ergebnis = i + j + k;//rechnet jetzt mit drei Zahlen
		System.out.println(ergebnis);
	}

	
	public static void main(String[] args) {
		addiere(2, 4, 8); //Methodenaufruf mit drei Argumenten für die Parameter
	}
}

Klick auf „RUN“.
Und läuft, oder?

Aber es besteht mindestens ein Problem.
Und zwar musst du jetzt zwingend 3 Argumente übergeben.

Denn….
Das Teil rechnet nicht mehr mit zwei Zahlen und es rechnet natürlich auch nicht mit vier.

Also meine Frage an Dich:

„Wie könnte jetzt eine vernünftige Java Methode aussehen?“

Eine Möglichkeit besteht darin, mehrere Parameterlisten in mehreren Java Methoden anzubieten.

Stichwort: Methoden überladen.

Denn dadurch kannst du ein- und dieselbe Methode mit unterschiedlichen Parameterlisten führen.
Und dadurch auch mit unterschiedlicher Anzahl an Argumenten aufrufen.

public class JavaVarArgsDemo {
	
	//Methode mit zwei Parametern i - j
	static void addiere(int i, int j) {
		int ergebnis = i + j;//rechnet mit zwei Zahlen
		System.out.println(ergebnis);
	}
	
	//Methode mit drei Parametern i - j und k
	static void addiere(int i, int j, int k) {
		int ergebnis = i + j + k;//rechnet jetzt mit drei Zahlen
		System.out.println(ergebnis);
	}

	//Methode mit vier  Parametern i - j - k und m
	static void addiere(int i, int j, int k, int m) {
		int ergebnis = i + j + k + m;//rechnet jetzt mit vier Zahlen
		System.out.println(ergebnis);
	}
	
	public static void main(String[] args) {
		addiere(2,4);//Methodenaufruf mit zwei Argumenten
		addiere(2, 4, 8); //Methodenaufruf mit drei Argumenten für die Parameter
		addiere(2, 4, 8, 9);//Methode mit vier Argumenten
	}
}

Diese Nummer geht eine ganze Weile gut.
Aber du siehst schon, wo und wann die Reise endet – Nämlich niemals.

Du kannst diese Methode in 100 Varianten anbieten und dadurch können deine User bis zu 100 Zahlen addieren.
Aber irgendwann ist es soweit.
Irgendjemand möchte noch eine weitere Zahl dazu addieren.
Und dann gibt es 101 Varianten.

Dieses Spiel geht ins Unendliche.
Somit ist klar – Das Überladen von Java Methoden hat, bei diesem Problem, praktische Grenzen.

Aber zum Glück gibt es Arrays.

Möglichkeit 2: Java Methoden mit Arrays in der Parameterliste

Meine Idee:

• Wir führen in der Parameterliste der Methode ein Array.
• Und schließlich können wir dem Array so einige Werte übergeben.
  Nicht unendlich viele, aber dennoch ausreichend.

Gesagt, getan:

public class JavaVarArgsDemo {
	
	//Methode erwartet jetzt ein Inter-Array
	static void addiere(int zahlen []) {
		int ergebnis =0;
		for (int i =0; i< zahlen.length; i++){
			ergebnis = zahlen[i] + ergebnis;
		}
		System.out.println(ergebnis);
	}
	
	public static void main(String[] args) {
		int zahlen [] = new int [5];//Array mit Länge 5
		zahlen[0]=2;
		zahlen[1]=4;
		zahlen[2]=8;
		zahlen[3]=9;
		addiere(zahlen);//Methodenaufruf mit Array als Argument
	}
}

Ganz kurz erklärt.

• In der main-Methode habe ich zum Programmstart ein Array mit der Länge 5 angelegt.
  Dieses trägt den Namen „zahlen“.
• Und die ersten vier Fächer (0 bis 3) wurden bereits mit Zahlen belegt.
• Die „addieren()-Methode“ erwartet jetzt keine Zahlen mehr, sondern ein Integer-Array.
  Und genau dieses bekommt sie beim Aufruf übergeben.
• Im Rumpf der „addieren()-Methode“ liest eine for-Schleife die einzelnen Fächer aus und addiert diese auf.

Aber das wirklich Smarte ist….
Im Methodenrumpf der „addieren()-Methode“ könntest du das Array beliebig erweitern.
Wie dies funktioniert, habe ich bereits schon einmal ausgiebig gezeigt. – hier klicken.

Mit ein paar if/else Ausdrücken könntest du dies dann auch recht flexibel gestalten.

Aber du merkst es schon…
Ich gehe nicht weiter darauf ein.

Es gibt nämlich etwas Besseres.
Und dazu komme ich jetzt.

Finale: Java Methoden mit VarArgs aufrufen.

Diese VarArgs sind ein Feature, welches Java standardisiert ausliefert.
Es ist also bereits vorhanden und du musst es nicht erst programmieren.

Dazu benötigst du erst einmal wieder die ganz normale Methode mit zwei Integer-Parametern.
Ich nenne diese jetzt ganz bewusst summand1 und summand2.
Denn eine lokale Variable namens „i“ brauchen wir gleich noch.

public class JavaVarArgsDemo {
	
	static void addiere(int summand1, int summand2) {
		int ergebnis = summand1 + summand2;
		System.out.println(ergebnis);
	}
	
	public static void main(String[] args) {
		addiere(2 ,4);//mit zwei Argumenten
	}
}

Und jetzt packst du einen weiteren Parameter hinein.
Und zwar ebenfalls vom Typ Integer.
int … summandX

Du siehst die drei Punkte?
Sieht komisch aus, oder?
Aber diese drei Punkte signalisieren Java – „Jetzt kommt eine variable Anzahl an Zahlen!!!“

Intern wird jetzt die Variable „summandX“ als Array geführt.
Und deshalb musst du es wie ein Array auslesen.

Somit kommt wieder eine for-Schleife ins Spiel.
Deshalb brauchst du eine Variable „i“ als Index- bzw. Zählparameter für die Schleife.
Und aus diesem Grund sollte der Parameter in der Parameterliste nicht genauso heißen.
(Aus „i“ wurde „summand1“)

Also dann.
Hier ist der Code:

public class JavaVarArgsDemo {
	
	static void addiere(int summand1, int summand2, int ...summandX) {
		int ergebnis = summand1 + summand2;
		for (int i = 0; i < summandX.length; i++){
			ergebnis = summandX[i]+ergebnis;
		}
		System.out.println(ergebnis);
	}
	
	public static void main(String[] args) {
		addiere(2 ,4);//mit zwei Argumenten
		addiere(2, 4, 6, 8, 10, 12, 14, 16);//Aufruf mit mehreren Argumenten
	}
}

Klicke nochmals auf „RUN“ und probiere es selbst aus.

Cool, oder?
Jetzt kannst du die Java Methode mit einer beliebigen Anzahl an Argumenten oder Summanden aufrufen.
Es handelt sich jetzt um eine echte Kettenaufgabe.

Zusammenfassung:

• Für variable Parameterlisten gibt es in Java Methoden das Feature VarArgs.
• Dazu kannst du einen Parameter anlegen und den Namen mit drei Punkten versehen.
• Dadurch ist es dir möglich eine variable Anzahl an Werten oder Argumenten der Methode zu übergeben.
• Im Methodenrumpf musst du dann die variablen Argumentenliste, wie jedes andere Java Array behandeln.
  Du kannst die Werte mit Schleifen, wie der for-Schleife, auslesen und verrechnen.