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

Polymorphie bringt Vorteile für Java Arrays

Java Polymorphie Arrays

Wenn Java Arrays, Schubladen oder Container sein sollen… Dann wäre der Gebrauch einer solchen Schublade ziemlich einseitig und festgefahren. Denn in jedes Array passen zwar mehrere Daten – aber immer nur vom gleichen Datentyp. Immer gleicher Datentyp? Also eine Schublade nur für Socken, Unterwäsche und der ganze andere Kram passt dann eben nicht hinein. Um […]

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 […]

Java Vererbung:
Die 3 Schablonen für deine Java Objekte

Java Vererbung Beispiel

Im letzten Beitrag habe ich dir das Java Vererbung Konzept an einem Beispiel vorgestellt. In dem Beispiel-Rollenspiel gab es Klassen zu Helden und Superhelden. Ich habe dir die Vererbungshierarchien theoretisch erläutert. Jetzt geht es ans Praktische. In diesen Beitrag lernst du: Wie du bestehende Java Klassen erweiterst Wie du Objekte aus den erweiterten Klassen erstellen […]

So kannst du in Java Und Verknüpfung anlegen und auswerten

Java Und

In Java stehen dir eine Menge Operatoren zur Verfügung. Einer dieser Operatoren ist der Und-Operator. Dies ist ein logischer Operator, da dieser sogenannte Wahrheitswerte mit einander verknüpft. Also…. Was erwartet dich in diesem Beitrag? Zuerst möchte ich dir die Aussagenlogik hinter dem Und-Operator zeigen. Also wann sind Aussagen wahr und wann sind diese falsch. Dann […]

Java lernen durch ständiges Testen – Nutze die Testumgebung von Eclipse

Java Programmierung lernen

Probieren geht über studieren Wenn du wirklich Java Programmierung lernen möchtest, dann solltest du Java nicht aus einem Buch lernen. Du solltest auch nicht strikt von dieser oder anderen Webseiten lernen. Etwas wirklich zu lernen, setzt die Bereitschaft voraus, etwas zu probieren. Denn nur durch eigenes Probieren gelangst du zum Wesentlichen. Durch Probieren wirst du […]

Ohne Abstraktion ergibt Java Polymorphie wenig Sinn

Java Polymorphie Abstraktionsprinzip

Kennst du den Film Matrix? Denn kennst du vielleicht auch die Botschaft, welche der Protagonist am Anfang des Filmes erhält. „Folge dem weißen Kaninchen.“ Und so ähnlich ist es jetzt auch in diesem Beitrag. „Wir dringen immer tiefer in den Kaninchenbau ein.“ 🙂 Ganz so wie im Film wird es nicht. Aber bevor wir mit […]

Drei Möglichkeiten um Java Objekte zu zerstören

Java Objekte zerstören

Java Objekte leben genau solange, wie eine Referenzvariable auf sie zeigt. Wenn dieser Zeiger nicht mehr existiert, wird dieses Objekt aufgeben. Und wenn dieses Objekt erst einmal aufgegeben wurde, dann kommt der Garbage Collector und entsorgt dieses. Aber wie kannst du nun am Sinnvollsten Objekte aufgeben? Lass es uns herausfinden.

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 kannst du in drei einfachen Schritten Java Arrays dynamisch vergrößern

Java Arrays vergrößern

Es ist der 31.März 1727. Es ist ein Montag. Die Welt nimmt Abschied von einem sehr bedeutenden Weltveränderer. Seine Sichtweisen beeinflussen, heute noch, die Forschung und Entwicklung im Bereichen der Physik und Chemie. Ja selbst unser aller Leben – unsere Sicht auf die alltäglichen Dinge – wurden durch seine Denkstöße revolutioniert. Dieser große Vorreiter starb […]