Input/Output switch case - Parameterübergabe args[0]

[Kel]

Es soll eine Zahl als Parameter auf der Konsole eingegeben werden, die dann eine switch-case Abfrage erlaubt und den Wert zurückgibt.
Ich weiss jetzt nur nicht, wie ich den Parameter an die switch-case-Kette weitergebe, sodass die richtige Fallunterscheidung genommen wird.
Aktuell wird immer der default-Wert zurückgegeben, aber dass solls ja nicht sein.

public class Olympia {
	
	int jahr;
	
	public Olympia() {
	
	}
	void olympiastadt() {
		switch (jahr) {
			case 1980:
				System.out.println("Moskau");
				break;
			case 1988:
				System.out.println("Seoul");
				break;
			case 1992:
				System.out.println("Barcelona");
				break;
			case 1996:
				System.out.println("Atlanta");
				break;
			case 2000:
				System.out.println("Sydney");
				break;
			case 2008:
				System.out.println("Peking");
				break;
			default:
				System.out.println("keine Spiele oder keine Stadt");
		}
	}

	public static void main(String[] args) {
	int jahr = Integer.parseInt(args[0]);
	Olympia aufgabe = new Olympia();
	aufgabe.olympiastadt();
	}

}

 

[Gast2]

Die eingelesene Zahl ist nur innerhalb der main gültig. Du kannst die Zahl aber z.b. im Konstruktor übergeben:

public class Olympia {
    
    int jahr;
    
    public Olympia(int jahr) {
        this.jahr = jahr;
    }

    void olympiastadt() {
        switch (jahr) {
            case 1980:
                System.out.println("Moskau");
                break;
            case 1988:
                System.out.println("Seoul");
                break;
            case 1992:
                System.out.println("Barcelona");
                break;
            case 1996:
                System.out.println("Atlanta");
                break;
            case 2000:
                System.out.println("Sydney");
                break;
            case 2008:
                System.out.println("Peking");
                break;
            default:
                System.out.println("keine Spiele oder keine Stadt");
        }
    }
 
    public static void main(String[] args) {
        int jahr = Integer.parseInt(args[0]);
        Olympia aufgabe = new Olympia(jahr);
        aufgabe.olympiastadt();
    }
}

 

[XHelp]

Im Moment hast du 2 Variablen

jahr

, die absolut gar nichts miteinander zu tun haben. Du musst die Variable

jahr

der Instanz von Olympia ändern und nicht einfach eine neue erstellen. Setter würde sich da anbieten. Oder im Konstruktor übergeben

 

[Kel]

Setter/Gettermethoden hatten wir noch nicht, ich nehm die Konstruktorvariante.
Was bewirkt eigentlich

this.jahr = jahr;

?

 

[Gast2]

this.jahr

ist die instanzvariable deiner klasse Olympia.

jahr

ist die Variable die im Konstruktor übergeben wird.

 

[Kel]

Also frage ich die Variable in der main-Methode ab, übergebe sie der neuen Instanz meines Konstruktors und verwende sie dann mittels this.variable = variable innerhalb meiner Instanzmethode(n)?

Oder gibs da noch einen einfacheren Weg?
Ich hab jetzt noch die Zusatzaufgabe erledigt, dass nur 1 Parameter mitgegeben werden darf. Mich stört daran, dass ich anzahl = args.lenght doch nicht exklusiv in der main-Methode haben müsste, theoretisch könnte ich das doch auch direkt im Konstruktor deklarieren, die Instanz erbt doch vom Konstruktor?
Oder ist das so, wie ich das jetzt habe, allgemein anerkannte, gute Javasyntax?

public class Olympia {
	
	int jahr;
	int anzahl;
	
	public Olympia(int jahr, int anzahl) {
		this.jahr = jahr;
		this.anzahl = anzahl;
	}
	void olympiastadt() {
		if (anzahl != 1) {
			System.out.println("Nur eine Jahreszahl");
		}
		else {
		switch (jahr) {
			case 1980:
				System.out.println("Moskau");
				break;
			case 1988:
				System.out.println("Seoul");
				break;
			case 1992:
				System.out.println("Barcelona");
				break;
			case 1996:
				System.out.println("Atlanta");
				break;
			case 2000:
				System.out.println("Sydney");
				break;
			case 2008:
				System.out.println("Peking");
				break;
			default:
				System.out.println("keine Spiele oder keine Stadt");
		}
		}
	}

	public static void main(String[] args) {
	int jahr = Integer.parseInt(args[0]);
	int anzahl = args.length;
	Olympia aufgabe = new Olympia(jahr, anzahl);
	aufgabe.olympiastadt();
	}

}

 

[Volvagia]

die Instanz erbt doch vom Konstruktor?

Den Gedankenvorgang hätte ich gerne genauer erklärt. ???:L

Ich würde das ganze direkt in der Main handlen, denn Olympia geht es ja eigendlich nichts an, wie viele Parameter eingegeben wurden. Außerdem, da du zuerst die Parameter ausließt und dann erst die Länge prüfst.

public static void main(String[] args) {
    if(args.lenght != 1) {
        System.out.println("Bitte exakt eine Jahreszahl angeben.");
        return;
    }

    int jahr = Integer.parseInt(args[0]);
    Olympia aufgabe = new Olympia(jahr);
    aufgabe.olympiastadt();
}

PS: Anerkannter guter Javasyntax hilft dir garnichts, wenn du damit nicht klarkommst. Man sollte als Erstes immer schauen, dass man selbst damit gut arbeiten kann.

 

[Kel]

Außerdem, da du zuerst die Parameter ausließt und dann erst die Länge prüfst.

Bei deinem Beispiel ist das doch andersrum, da wird erst die Größe des Arrays bestimmt und dann der Parameter eingelesen ???:L.

Bei meinem Code klappt soweit alles, nur wenn ich gar keinen Parameter eingebe, hauts mir n

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 0
at Olympia.main(Olympia.java:41)

, was eigentlich durch die if-Abfrage verhindert werden sollte.

public class Olympia {

	int jahr;
	int anzahl;
		
	public Olympia(int jahr, int anzahl) {
		this.jahr = jahr;
		this.anzahl = anzahl;
	}
	void olympiastadt() {
		if (anzahl != 1) {
			System.out.println("Nur eine Jahreszahl");
		}
		else {
		switch (jahr) {
			case 1980:
				System.out.println("Moskau");
				break;
			case 1988:
				System.out.println("Seoul");
				break;
			case 1992:
				System.out.println("Barcelona");
				break;
			case 1996:
				System.out.println("Atlanta");
				break;
			case 2000:
				System.out.println("Sydney");
				break;
			case 2008:
				System.out.println("Peking");
				break;
			default:
				System.out.println("keine Spiele oder keine Stadt");
		}
		}
	}

	public static void main(String[] args) {
	int jahr = Integer.parseInt(args[0]);
	int anzahl = args.length;
	Olympia aufgabe = new Olympia(jahr, anzahl);
	aufgabe.olympiastadt();
	}
}

 

[Michael...]

was eigentlich durch die if-Abfrage verhindert werden sollte.

Die kommt zu spät ;-)
==> erst die Länge des Arrays überprüfen und dann (falls lenght==1) arg[0] auslesen.

 

[Sym]

Die Exception bekommst Du, weil Du zunächst

int jahr = Integer.parseInt(args[0]);

aufrufst. Du gehst in der Zeile davon aus, dass es mindestens ein Argument gibt.

Volvagia macht es da besser, da zunächst geprüft wird, ob es entsprechende Argumente gibt und im Fehlerfall das Programm beendet.

 

[Kel]

Wenn ich die Länge eines Arrays überprüfen kann, ohne dass ich es vorher deklarieren muss, würde dass ja bedeuten, dass ich jedem Programm unendlich viele Parameter übergeben könnte auf der Konsole.
Oder ist die Deklaration in der main-Methode mit (String[] args) müsste es nicht eigentlich (String args[] heissen? Oder ist das egal)?

Heisst, ich kann soviele Paramter eingeben wie ich will, die Länge des Arrays und/oder einzelner Arrayelemente kann ich auch später überprüfen/damit rechnen.

Und mein Pufferüberlauf? Overflow? kommt zustande, weil ich eine nicht vorhandene Eingabe in eine Zahl umwandle, was als Ergebnis ... naja, kein Ergebnis hat und ich damit trotzdem weiterrechnen will?

 

[Volvagia]

Es ist egal, aber trotzdem sollte man die Klammern immer nach den Typ setzen.
Ein Buffer Overflow hat damit nichts zu tun. Das kommt, wenn man zu große Datenmengen und einen zu kleinen RAM-Bereich schreiben will, wodurch die Daten außerhalb dieses Bereichs überschrieben werden.

Ob die Zeichen in der Konsole begrenzt sind weiß ich nicht, wenn dann wohl auf 255 Zeichen.

 

[Michael...]

Wenn ich die Länge eines Arrays überprüfen kann, ohne dass ich es vorher deklarieren muss, würde dass ja bedeuten, dass ich jedem Programm unendlich viele Parameter übergeben könnte auf der Konsole.

Nein nur maximal 2.147.483.647 ;-) da der Index eines Arrays ein int ist.

Oder ist die Deklaration in der main-Methode mit (String[] args) müsste es nicht eigentlich (String args[] heissen? Oder ist das egal)?

Ist zwar egal, aber üblicher Weise stehen die [] beim Datentyp und nicht beim Namen der Variable. Hier handelt es sich ja um ein String-Array.

Heisst, ich kann soviele Paramter eingeben wie ich will, die Länge des Arrays und/oder einzelner Arrayelemente kann ich auch später überprüfen/damit rechnen.

????

Und mein Pufferüberlauf? Overflow? kommt zustande, weil ich eine nicht vorhandene Eingabe in eine Zahl umwandle, was als Ergebnis ... naja, kein Ergebnis hat und ich damit trotzdem weiterrechnen will?

Welcher Pufferüberlauf? Overflow? Du bekommst eine Exception, da Du auf einen Index im Array zugreifen willst, der nicht existiert.

 

[Kel]

Okay, jetzt bin ich wieder schlauer .

Mit

Heisst, ich kann soviele Paramter eingeben wie ich will, die Länge des Arrays und/oder einzelner Arrayelemente kann ich auch später überprüfen/damit rechnen.

meinte ich, dass ich bisher dachte, ich kann nur Parameter angeben, wenn ich sie auch abfrage, weil, wo sollen die Parameter sonst auch hin? War wohl ein großer Denkfehler.

 

[Sym]

Die Parameter gehen ja nirgendwo hin. Sie liegen im Speicher und Du bekommst Zugriff darauf. Ob Du das nutzt oder nicht ist der VM egal

 

[Kel]

Kurze Frage:
Was bewirkt das "return"?

if(args.lenght != 1) {
        System.out.println("Bitte exakt eine Jahreszahl angeben.");
        return;
    }

Ohne das "return" greife ich ja ohne Parameter immernoch auf einen Bereich ausserhalb des Arrays zu, also muss das "return" irgendwas abbrechen, nur wie funktioniert das?
Der Bereich ausserhalb der if-Schleife wird dadurch ignoriert.

 

[Volvagia]

Return verlässt die aktuelle Methode.
Da du zu dem Zeitpunkt selbst keinen (nicht-dämonen-)Thread gestartet, oder ein Fensterelement angezeigt hast, beendet das Programm.

 

[Kel]

Also beendet return nicht nur die if-Schleife, sondern die ganze main-Methode?

 

[Gast2]

if-schleife.de

Ja, ein return beended/verlässt die aktuelle Methode. Wenn du return in der main Methode erreichst beendest du in der Regel auch dein Program. (es sei denn du nutzt Threads oder stellst auf andere Art sicher das das Program weiterläuft)

 

[Volvagia]

Ja. Da sie in Java void ist, wird nichts zurückgegeben, dadurch brauchst du kein return am Ende.
Wenn du eine Methode, die etwas zurückgibt, wie z. B. int anlegst, musst du immer mit return (oder einer Exception) zurückkehren:

public static int getFour() {
	return(4);
}

Schleifen (do, while, for) und switch kannst du mit "break;" sofort beenden, ob es bei if geht weiß ich nicht.

 

[Gast2]

Job es bei if geht weiß ich nicht.

Nein, geht nicht.

Nebenbei gibt es für Schleifen auch noch [c]continue[/c] und Labels.

 

[Kel]

ich merk grad, dass mir mein Programm wieder um die Ohren fliegt, wenn man statt Zahlen irgendwas einträgt. Verträgt sich wohl nicht so gut mit dem casten nach Int.

Exception in thread "main" java.lang.NumberFormatException: For input string: "a
s"
at java.lang.NumberFormatException.forInputString(Unknown Source)
at java.lang.Integer.parseInt(Unknown Source)
at java.lang.Integer.parseInt(Unknown Source)
at Olympia.main(Olympia.java:41)

Kann man das irgendwie verhindern?

 

[Volvagia]

Du könntest es mit einen try/catch umgeben, und die NumberFormatException abfangen. Im catch kannst du Fehlermeldungen ausgeben und abbrechen.
Alternativ kannst du auch vorher mit Character#isDigit(char) durchlaufen und so prüfen.

 

[Kel]

Ich probiers grade mit try/catch, aber ich greif anscheinend auf Klassenvariablen zu, während ich eine neue Instanz mittels Konstruktor erzeuge.

Olympia.java:97: non-static variable jahr cannot be referenced from a static con
text
Olympia aufgabe = new Olympia(jahr, anzahl);
^
1 error

public class Olympia {

	int jahr;
	int anzahl;
		
	public Olympia(int jahr, int anzahl) {
		this.jahr = jahr;
		this.anzahl = anzahl;
	}
	void olympiastadt() {
			switch (jahr) {
				case 1896: // Stack-Case-Labels
				case 2004:
					System.out.println("Athen");
					break;

				default:
					System.out.println("keine Spiele oder keine Stadt");
			}
	}

	public static void main(String[] args) {
		if (args.length != 1) {
			System.out.println("Nur eine Jahreszahl");
			return;
		}
		
		try {
			int jahr = Integer.parseInt(args[0]);
		} catch (NumberFormatException e) {
			System.out.println("Zahl eingeben und nicht " + e);
		}
		
		
		int anzahl = args.length;
		Olympia aufgabe = new Olympia(jahr, anzahl);
		aufgabe.olympiastadt();
	}

}

/e wenn ich am Anfang der main-Methode

int jahr = 0;

vorher deklariere und initialisiere (wieso muss ich sie initialisieren, dachte Standard wäre 0?), dann läufts. Fängt die Exception jetzt ab .

public static void main(String[] args) {
		int jahr = 0;
		if (args.length != 1) {
			System.out.println("Nur eine Jahreszahl");
			return;
		}
		
		try {
			jahr = Integer.parseInt(args[0]);
		} catch (NumberFormatException e) {
			System.out.println("Zahl eingeben und nicht " + e);
		}
		
		
		int anzahl = args.length;
		Olympia aufgabe = new Olympia(jahr, anzahl);
		aufgabe.olympiastadt();
	}

 

[Volvagia]

Liegt daran, das eine Variable innerhalb von Blöcken deklariert (try, if, for, while etc.) auch nur innerhalb dieser Blöcke sichtbar ist. Ausgenommen synchronized, da dieser Block immer abgearbeitet wird. (Sofern man keinen Deadlock baut, aber dann ist es auch schon egal). Methodenvariablen müssen immer Werte zugewiesen werden, bevor sie gelesen werden. In einen try ist es nicht sicher, das der jeweilige Schreibzugriff auch durchgeführt wird, deshalb musst du schon vorher etwas hineinschreiben. Bei Klassenvariablen ist die Variable immer automatisch 0/false/null.

So intialisiert er übrigens bei falscher Eingabe ein Olympia-Objekt mit dem Jahr 0. Du solltest noch ein return; oder System.exit(1); etc. in den catch schreiben.

Die Exception kam daher, dass du die gleichnahmige Klassenvariable jahr hast, auf die er zugreifen wollte, da er die Methodenvariable ja nicht gesehen hat. Da sie nicht statisch ist kannst du natürlich von der statischen Main nicht darauf zugreifen.

 

[Kel]

So intialisiert er übrigens bei falscher Eingabe ein Olympia-Objekt mit dem Jahr 0. Du solltest noch ein return; oder System.exit(1); etc. in den catch schreiben.

Ich fange Eingaben ab, die sich nicht zu Int casten lassen und bei Zahlen, die keine eindeutige Zuweisung bei switch-case haben, greift die default-Variante.

Was ist so schlimm daran, wenn ich der Instanz ein jahr=0 mitgebe? Dann krieg ich doch meine default-Ausgabe?

 

[Volvagia]

Nichts ist daran schlimm, du bekommst dann aber auch wenn der Anwender z. B. "java" eingibt

Zahl eingeben und nicht java.lang.NumberFormatException: For input string: "java"
keine Spiele oder keine Stadt

 

[Kel]

Wenn ich also den try/catch-Block nicht abbreche, dann wird mit jahr=0 die Variable als Instanzvariable an mein Objekt vom Konstruktor weitergegeben und damit gibt es dann die default-Ausgabe meiner switch-case-Zuweisung auf der Konsole, zusätzlich zur eventuellen Ausgabe meiner geworfenen Exception.

Soweit richtig?

 

[Volvagia]

"im try/catch-Block", aber ja.

 

[Kel]

Ich muss das hier leider nochmal aufmachen, nachdem ich mein Programm noch etwas verbessern wollte und deshalb alles in eine if-else Schleife gepackt habe.
Ich weiss nicht, was da schief läuft.

Ich übergebe dem Konstruktor beim Erzeugen der Instanz "aufgabe" ja die Variable "jahr", der Konstruktor macht sie mit "this.jahr = jahr;" zur Instanzvariable und mit Aufruf der Methode "olympiastadt" der Instanz "aufgabe" solls losgehen.
Aber irgendwo ist wohl die Parameterübergabe falsch ???:L.

/edit Wenn ich

aufgabe.olympiastadt(jahr);

schreibe, dann funktioniert es, aber der Parameter wird doch schon beim Erzeugen der Instanz übergeben oder nicht?
Und den obigen Codebeispielen wird der Parameter auch nicht beim Instanzaufruf übergeben.
Blick das grad nicht.

Olympia.java:36: olympiastadt(int) in Olympia cannot be applied to ()
aufgabe.olympiastadt();
^
1 error

public class Olympia {

	int jahr;
		
	public Olympia(int jahr) {
		this.jahr = jahr;
	}
	void olympiastadt(int jahr) {
			switch (jahr) {
				case 1896: // Stack-Case-Labels
				case 2004:
					System.out.println("Athen");
					break;
				default:
					System.out.println("keine Spiele oder keine Stadt");
			}
	}

	public static void main(String[] args) {
		int anzahl = args.length;
		int jahr;
		
		if (args.length != 1) {
			System.out.println("Nur eine Jahreszahl");
		}
		else {
			try {
			jahr = Integer.parseInt(args[0]);
			}
			catch (NumberFormatException e) {
			System.out.println("Jahreszahl eingeben und nicht " + args[0]);
			System.out.println(e);
			return;
			}
			Olympia aufgabe = new Olympia(jahr);
			aufgabe.olympiastadt();
		}
	}

}

 

[Michael...]

Die Methode heisst

 void olympiastadt(int jahr)

, d.h. Du muss Ihr beim Aufruf auch einen int als Parameter übergeben.
Mit dieser Methode ist im Übrigen die Übergabe der Jahreszahl an den Konstruktor bzw. der Konstruktor selbst überflüssig.

 

[Kel]

Ich dachte, man kann Methoden nur über Instanzierung aufrufen? Wie geht das den ohne Konstruktor?

 

[Michael...]

Es gibt noch statische Methoden, die ruft man direkt an der Klasse auf.

Ansonsten hat - wenn man selbst keinen definiert - jede Klasse einen parameterlosen Standardkonstruktor.

 

[Michael...]

Bedeutet für Dein Beispiel:

public class Olympia {
    public void olympiastadt(int jahr) {
            switch (jahr) {
                case 1896: // Stack-Case-Labels
                case 2004:
                    System.out.println("Athen");
                    break;
                default:
                    System.out.println("keine Spiele oder keine Stadt");
            }
    }
 
    public static void main(String[] args) {
       //hier das ganze Vorgeplänkel
       int jahr = ...
       Olympia aufgabe = new Olympia();
       aufgabe.olympiastadt(jahr);
       
       //Aufruf statischer Methoden
       Olympia.staticOlypic(year);
    }

    public static void staticOlypic(int year) {
        ...
    }
}

 

[Kel]

Okay, das ist grade ziemlich verwirrend.

Ist das sowas wie

Die Methode main() ist für die Laufzeitumgebung etwas ganz Besonderes, denn beim Aufruf des Java-Interpreters mit einem Klassennamen wird unsere Methode als Erstes ausgeführt. [Na ja, so ganz präzise ist das auch nicht. In einem static-Block könnten wir auch einen Funktionsaufruf setzen.
static-Blöcke werden beim Laden der Klassen in die virtuelle Maschine ausgeführt

Der Modifizierer static zwingt den Programmierer nicht dazu, vor dem Methodenaufruf ein Objekt der Klasse zu bilden. Anders gesagt, die Eigenschaft, ob sich eine Methode nur über ein konkretes Objekt aufrufen lässt oder eine Eigenschaft der Klasse ist, sodass für den Aufruf kein Objekt der Klasse nötig wird, bestimmt dieser Modifizierer.

Quelle: Java ist auch eine Insel, 2.2.10

Okay, grade etwas rumexperimentiert

public static void olympiastadt(int jahr) {
			switch (jahr) {
				case 1896: // Stack-Case-Labels
				case 2004:
					System.out.println("Athen");
					break;
				default:
					System.out.println("keine Spiele oder keine Stadt");
			}

	public static void main(String[] args) {
                        // vorheriger Kram
			Olympia.olympiastadt(jahr);		
		}
	
	}
	}

Gut zu wissen, aktuell brauch ich ja noch keine Objekte, dann kann ich mir einen angepassten Konstruktor sparen und mit static einfach direkt eine Methode der Klasse starten.