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 nutzt du die While Schleife in deinem Java Programm

Java While Schleife

Manchmal ist es wichtig, Dinge einmal öfter zu tun. Bei der Java Programmierung kann es schonmal sein, dass du einen Code mehrfach ausführen lassen musst. Zum Beispiel die Zahlen eins bis zehn. Ein Java Programm, welches die Zahlen eins bis zehn wiedergibt. Na wie wäre das? Der Java Code dazu würde so aussehen: public class […]

So kannst du Java installieren

Java installieren

Bevor du loslegst und deine ersten Java Programme schreibst, benötigst du die entsprechende Arbeitsumgebung. Du solltest also Java installieren. Und diese Arbeitsumgebung beinhaltet dann Bibliotheken für die einzelnen Java-Standard-Klassen, Dateien um deine Programme auszuführen. Dateien um deine Programme zu packen, Logische Verzeichnisstrukturen

So verwendest du den Java Oder Operator

Java Oder Operator

Kennst du das auch aus deiner Schulzeit? Du schreibst eine Klassenarbeit in irgendeinem Fach. Nehmen wir einfach mal an – Mathe. Jetzt bist gerade fertig mit deiner Arbeit. Und zu Hause wirst du gefragt: „Und wie lief es?“ Du antwortet:“ Ganz gut. Es wird bestimmt eine Eins oder eine Zwei.“ Drei oder vier Tage später […]

So richtest du einen Schreibschutz für deine Java Variablen ein

Stell dir vor: Du hast erfolgreich dein erstes Programm für die Personalabteilung aufgesetzt. Du hast deine ersten 1000 Datensätze schön sauber angelegt. Und nun kommt dein Kollege und überschreibt die Vornamen der ersten 100 Mitarbeitern. Na schöne Sch…. 🙂 Wie kann das passieren? Wie kann man das verhindern? Du brauchst eigentlich nur deine Java Variablen […]

So kannst du in den Java Klassen Attribute anlegen

Java Klassen Attribute

Die bisherigen Java Klassen in unserem Einführungsbeispiel besitzen noch keine Attribute. Das ändern wir und legen diese jetzt an. In diesem Beitrag erfährst du: Warum Variablen in deinen Klassen eine entscheidende Rolle spielen. Was es bedeutet eine Variable zu deklarieren. Wo du Attribute in den Java Klassen anlegen darfst und wo nicht. Wie du durch […]

So erstellst du deine ersten Java Klassen mit Eclipse

Java Klassen sind Baupläne für Java Objekte. Und da Java eine objektorientierte Programmiersprache ist, sind Java Klassen somit ein elementarer Bestandteil. In diesem Beitrag möchte ich dir zeigen, wie du eine Java Klasse in Eclipse erstellen kannst. Ich möchte dir außerdem zeigen, was physikalisch in deinem Projekt passiert. Ganz zum Schluss zeige ich dir noch, […]

Über das kurze Leben einer lokalen Variablen

Java Variable lokal

Lass uns über die Lebensdauer einer lokalen Variablen sprechen. Warum ausgerechnet die Lebensdauer? Alle Java Variablen, unterscheiden sich in folgenden Punkten: wo diese deklariert werden können, wie du diese aufrufen kannst, welchen Bereich diese abdecken, und Ihre Lebensdauer Und eine lokale Java Variable hat eine relativ kurze Lebensdauer. Schauen wir uns zuerst Klassen- und Instanzvariablen […]