Skip to main content

Java Methoden mit variabler Argumentenanzahl – VarArgs

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.

Java Methoden mit variabler Parameterliste

Zwei Schüler, welche sich eine Schulbank teilten – mussten aufstehen.
Der Lehrer stellte Matheaufgaben und derjenige, welche die Lösung zuerst hatte – schrie diese heraus.
Kein Melden, kein vorsichtiges Anfragen – einfach herausrufen.
Schließlich ging es um Schnelligkeit.

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. 🙂

Java Methoden Kettenaufgaben rechnen

Mathe mal anders.
Aus eigener Erfahrung, weiß ich – dass Lehrer dieses Spiel heute seltener spielen.
Es gibt schließlich einige aufgebrachte Eltern, welche der Meinung sind – dass bei einem solchen Duell, ihre Kinder bloß gestellt werden könnten.

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.

Ähnliche Beiträge

So kannst du deine Eclipse Oberfläche anpassen

Eclipse anpassen

In diesem Beitrag möchte ich dir zwei ganz nette Features von Eclipse vorstellen. Es geht um Views und um Perspektiven. Wie du schon weißt, besteht Eclipse aus einer grafischen Oberfläche. Und in dieser Oberfläche stehen dir verschiedene Views zur Verfügung. Was ist so ein View?

Ende vom Java Blog?

Falls du hier schon länger dabei bist, wird dir aufgefallen sein – dass kaum noch Beiträge veröffentlicht werden. Das tut mir wirklich leid und dafür möchte ich mich auch entschuldigen. Ich weiß, dass Einige unter Euch den Java-Blog wirklich lieben. Aber es ist verdammt schwierig so ein aufwendiges Thema – stilvoll, unterhaltend und methodisch umzusetzen. […]

Java Exklusives Oder – So nutzt du den Xor Operator

Java exklusives oder

In diesem Beitrag möchte ich dir den Xor Operator von Java vorstellen. Dieser Operator wird auch als ausschließendes oder exklusives Oder bezeichnet. Ein Beispiel: Was wilst du heute zum Mittag essen: Fleisch oder Fisch? Auf diese Frage gibt es nur eine Antwort. Es ist entweder Fisch oder Fleisch. Niemals beides. Das Eine schließt das andere […]

Java Exceptions Handling – Fehler- und Ausnahmenbehandlung in Java

Java Exceptions Handling

Java Exceptions Handling umfasst den richtigen Umgang mit Ausnahmen und Fehlern. Wie geht das? Und braucht man so etwas wirklich? Vielleicht sagst du jetzt: „Brauch ich nicht. Ich mache niemals Fehler.“ Doch… Bei der Java Fehlerbehandlung geht es nicht ausschließlich nur um deine Programmierfehler. Es geht auch um falsche Nutzereingaben, Hardware- und Ablauffehler. Und deshalb […]

So kannst du Java Konstruktoren anlegen und überladen

Java Konstruktoren

Der Name sagt es schon. Java Konstruktoren konstruieren oder bauen Java Objekte. Und diese Objekte baut der Konstruktor auf Vorlage der entsprechenden Java Klasse. In diesem Beitrag zeige ich dir natürlich verschiedene Ansätze wie du den Konstruktor einsetzt. Ich zeige dir dies Schritt für Schritt. Dabei zeige ich dir auch verschiedene Dinge, welche nicht funktionieren. […]

So einfach lassen sich Java Strings umkehren

Java Strings umkehren

Kennst du noch das Lied „ANNA“ von Freundeskreis? Da hieß es: Du bist von hinten, wie von vorne A-N-N-A. Solche Namen oder Wörter, welche von hinten nach vorne gelesen – die gleiche Bedeutung haben, nennt man Palindrome. Anna, Ehe oder Ebbe sind recht kurze Palindrome. Aber auch längere zusammengesetzte Palindrome kennt die deutsche Sprache: Regallager […]

Nutze die richtigen Methoden zum Java Lernen

Java lernen Methoden

Ich lernte die Java Programmierung auf die klassische Art. Ich kaufte mir das erste Buch und los ging es. „Jetzt wirst du Java lernen“ – sagte ich zu mir. Ich war relativ schnell ziemlich frustriert, denn irgendwie fehlten mir ein paar Zusammenhänge. Kennst du das? Du hast ein Wissensfetzen und noch einen. Aber das Wichtigste. […]