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 mit dem StringTokenizer Java Strings zerlegen oder splitten

Java StringTokenizer Java Strings teilen zerlegen splitten

Java StringTokenizer – was ist das? Bevor ich diese Frage kläre, schiebe ich eine zweite Frage hinterher. Denn im Wort Tokenizer steckt das Wort Token. Also was ist ein Token? Hier die Definition zum Token: Ein Token ist eine bestimmte Aneinanderreihung von Zeichen. Man kann auch sagen, eine lexikalische Einheit. Das kann zum Beispiel eine […]

Java Binärzahl in Dezimalzahl umwandeln – So geht’s.

Java-Binärzahl-umrechnen

Erinnerst du dich? In einer der letzten Beiträge haben wir uns die Zusammenhänge zwischen dem dualen und dem dezimalen Zahlensystem angeschaut. Aber wir haben noch keine Java Binärzahl in eine Dezimalzahl verwandelt. Zumindestens nicht praktisch…. Stattdessen…. Haben wir festgestellt, dass beide Zahlensysteme im Grunde genommen sehr ähnlich sind. Beim Dezimalsystem spielt die Zahl 10, als […]

So unterstützen dich Java Vererbungstabellen beim Entwurf

Java Vererbungstabellen

Bei der Java Vererbung gibt es zwei Klassenarten bzw. -stufen. Die Superklassen, welche einen allgemeinen Typen darstellen Und die spezielleren Unterklassen, welche die Superklasse um bestimmte Funktionen erweitern. Jetzt ist dieses ganze „Der-erbt-von-dem-Konzept“ mitunter sehr schwierig darzustellen. Zum Beispiel in einem Werkzeugkoffer. In einem Werkzeugkoffer befinden sich sämtliche Werkzeuge, von Säge bis Bohrmaschine. Wie machst […]

Sicherer Schleifendurchlauf mit Do while Schleife

Java Do While Schleife

Es ist doch eigentlich so: Immer wenn du die Anzahl der Schleifendurchläufe nicht kennst, nutzt du in deinen Java Programmen while Schleifen. Doch Java bietet dir neben der While Schleife einen weiteren Schleifentyp an. Diese nennt sich do while Schleife. Was kann die? Eigentlich genau das Gleiche, wie die while Schleife. Mit einem kleinen aber […]

Java For Each Schleife – Aufbau und Funktionsweise

Java for each Schleife

In einer anderen Lektion habe ich dir bereits gezeigt, wie du ein Java Array mit einer for-Schleife füllen und dir später die Werte zurückgeben lassen kannst. Es gibt allerdings einen weiteren Schleifentyp, welche geradezu prädestiniert ist für Java Arrays. Dieser Schleifentyp nennt sich for each Schleife. In diesem Beitrag möchte ich dir zeigen, wie du […]

Nutze das Keyword this für deine Java Konstruktoren

Java konstruktoren this

Es ist gemein. Wahrscheinlich hast den Beitrag zu den lokalen Variablen gelesen. Vielleicht hast du auch den Artikeln zum Anlegen und Überladen von Java Konstruktoren gelesen. Und wenn du die beschriebene Inhalte selbst ausprobiert hast…… Dann hast du dir wahrscheinlich sehr viele lokale Variablennamen für die Parameterliste ausdenken müssen.

Java for Schleifen schachteln – So funktioniert es

Java For Schleifen schachteln

Diese Situation kennst du doch auch…. Du stehst an der Haltestelle und wartest auf den Bus. Dein Blick fällt auf die Uhr.   Oder du wartest an der Ecke auf deinen Freund oder Kollegen. Immer wieder schaust du auf deine Uhr.   Sie ist kaum noch wegzudenken. Die mobile Taschenuhr.   Lange Zeit wurde die […]

Die drei Bestandteile aller Java Klassen

Java Klassen Bestandteile

Java ist eine objektorientierte Programmiersprache. Was heißt das? Ja… Anscheinend hat es etwas mit Objekten zu tun. Also was ist ein Objekt? Ein Objekt ist ein bestimmtes Konstrukt im Programm. Bauen wir ein Spiel. Ein Grafik-Adventure. Du kennst das. Ein Held wird in eine bestimmte Spielwelt hinein gesteckt. Der Held muss mit bestimmten Personen sprechen. […]

10 ganz nützlichen Feature der Klasse Java Math

In diesem Beitrag geht es um eine spezielle Java Klasse. Die Klasse nennt sich Java Math. Diese ist in der Standardbibliothek von Java enthalten. Warum solltest du diese Klasse kennen? Die Math Klasse bietet dir einen Menge Methoden an, welche zur Berechnung von mathematischen Gleichungen ganz hilfreich sind. Aber auch für Nichtmathematiker ist etwas dabei. […]

3 Möglichkeiten um Vererbung von Java Klassen zu verhindern, zu verbieten oder ausschließen

Java Vererbung verhindern

Die ganze Java Vererbung für bestimmte Klassen ausschließen bzw. verhindern oder verbieten. Was soll das? Für bestimmte Java Klassen soll die Vererbung ausgeschlossen werden. Es soll also verhindert werden, dass Elternklassen – Kindklassen bekommen können. Klingt ein bisschen wie Verhütung, oder? Denn wie auch im echten Leben, können Kinder zu kleinen Tyrannen werden. Sie bedienen […]

3 Möglichkeiten – Java Strings verketten und zusammenfügen

Java Strings verketten

Kennst du dieses Relikt längst vergangener Tage? Ein Brief. Ja früher einmal war es üblich, Briefe zu schreiben. Lange bevor es Smartphones oder Email gab. Man stelle sich einmal vor…. Die Leute mussten sich hinsetzen mit einem Blatt und einem Stift – und richtig schreiben. Nein nicht tippen – schreiben. 🙂 Grausame Welt, oder? Aber […]