Hilfe bei Java Problem

[hartloni]

Hallo, ich habe am Freitag ein Test in Java-Programmierung. Jetzt habe ich folgendes Problem:

public class Variable {

private double variable;

//Standardkonstruktor
public Variable(){
variable = 0.0;
}

//Übergabekonstruktor
public Variable(double _variable){
variable = _variable;
}

//set & get Methoden
public void setVariable(double _variable){
variable = _variable;
}
public double getVariable(){
return variable;
}

//zum Arbeiten mit den Methoden:
public void einlesen(){
System.out.println("Bitte Variable eingeben:");
_variable = Keyboard.readDouble();
}
public void ausgeben(){
System.out.println("Der Wert ist: "+variable);
}

}

Kann mir jemand helfen? Warum funktioniert das ganze nicht? Ich weiß dass ich nochmal eine Main-Klasse erstellen muss, aber der Fehler liegt im oben geschriebenen.

 

[Guy.brush]

Tipp: Wenn du nicht von selbst drauf kommst, den Compiler anwerfen (javac Variable.java).

Variable.java:26: cannot find symbol
symbol  : variable _variable
location: class Variable
_variable = Keyboard.readDouble();
^
Variable.java:26: cannot find symbol
symbol  : variable Keyboard
location: class Variable
_variable = Keyboard.readDouble();
            ^
2 errors

Im Café bist du mit deiner Frage übrigens völlig falsch und Standard schreibt sich glaub ich so.

 

[hartloni]

Naja ich dachte hier wäre der Offtopic-Bereich. Standard wird vermerkt.

Der Compiler sagt dass er die _variable nicht kennt, aber wenn ich sie vorher deklariere dann gibt er immer nur 0.0 aus, egal was ich eingebe. In unserem Beispiel in der Uni wird die _variable bei einlesen()... auch nicht deklariert. Die Keyboard.java ist zum Benutzen der Tastatur.

 

[Bierhefe]

Ich denke, dass der Fehler in der einlesen Methode zu finden ist (ich gehe mal davon aus, dass du die "Keyboard"-Class in deinem Projektordner hast)...

Du versuchst quasi deine Hilfsvariable aus den anderen Methoden durch eine Keyboard-Eingabe mit einem Wert zu belegen. Es kann aber nur funktionieren (es ergibt auch nur so einen Sinn), wenn du das Attribut der Klasse veränderst.

Ganz sauber sähe deine Klasse also so aus (ohne Compilerfehler und RTE):

public class Variable {
//Attribute:
private double variable;


//Standartkonstruktor
public Variable(){
	variable = 0.0;
}


//Übergabekonstruktor
public Variable(double _variable){
	this.variable = _variable;
}


//set & get Methoden
public void setVariable(double _variable){
	this.variable = _variable;
}
public double getVariable(){
	return this.variable;
}


//zum Arbeiten mit den Methoden:
public void einlesen(){
	System.out.println("Bitte Variable eingeben:");
	this.variable = Keyboard.readDouble();
}
public void ausgeben(){
	System.out.println("Der Wert ist: "+variable);
}
}

 

[hartloni]

Ah jetzt funktioniert es, vielen Dank. Aber gibt der jetzt nicht einfach den Wert den ich in einlesen eingebe, direkt wieder aus? Also im Prinzip ohne die Konstruktoren?!

 

[Bierhefe]

Den Konstruktor brauchst du ja nur, um beispielsweise in einer main-Methode ein neues Objekt vom Typ "Variable" zu erzeugen. Java geht die Programme nur innerhalb der Methoden chronologisch (also von oben nach unten) durch... das heißt ohne Aufruf von "ausgeben" gibst du auch nichts direkt wieder aus.

Ich wüsste kein Szenario in dem ein solcher Umweg erforderlich wäre.

 

[Loooki]

Java geht die Programme nur innerhalb der Methoden chronologisch (also von oben nach unten) durch... das heißt ohne Aufruf von "ausgeben" gibst du auch nichts direkt wieder aus.

In welcher Sprache denn sonst? Warum sollte der Compiler hin und her springen? Es sei denn man benutzt Sprungmarken aber die sind hier glaub ich nicht gemeint?

 

[XSkater]

ich dachte hier wäre der Offtopic-Bereich

In den Pro Foren?

Womit programmierst du, wenn ich fragen darf? Eclipse?

 

[wiebkes]

Die Konstruktoren werden verwendet.
Gehen wir mal von folgender main-methode aus:
public static void main(String[] args){
Variable var = new Variable(); //Standardkonstruktor wird verwendet
System.out.println(var.ausgeben()); //Ausgabe = 0.0 weil der Standardkonstruktor benutzt wird
Variable var2 = new Variable(7.5); //Übergabekonstruktor wird verwendet
System.out.println(var2.ausgeben()); //Ausgabe = 7.5 weil der Übergabekonstruktor genutzt wird
var.einlesen(); // Wert angabe = 8.0 z.B.
System.out.println(var.ausgeben()); //Ausgabe = 8.0 weil die Variable von Dir verändert wurde
Variable var3 = var2; //fieser trick var3 zeigt auf var2 (also zeigen beide auf dieselbe Speicheradresse)
System.out.println(var3.ausgeben); //Ausgabe = 7.5 weil var3 auf dieselbe Speicheradresse zeigt wie var2
//noch schlimmer:
var3.setVariable(15.7);
System.out.println(var2.ausgeben); //Ausgabe = 15.7 ja var 3 zeigt auf dieselbe Speicheradresse wie var2 und wenn der Wert an der Speicheradr. von var3 verändert wird, dann auch der von der Speicheradr von var2
}

 

[Loooki]

Die Konstruktoren werden verwendet.
Gehen wir mal von folgender main-methode aus:
public static void main(String[] args){
Variable var = new Variable(); //Standardkonstruktor wird verwendet
System.out.println(var.ausgeben()); //Ausgabe = 0.0 weil der Standardkonstruktor benutzt wird
Variable var2 = new Variable(7.5); //Übergabekonstruktor wird verwendet
System.out.println(var2.ausgeben()); //Ausgabe = 7.5 weil der Übergabekonstruktor genutzt wird
var.einlesen(); // Wert angabe = 8.0 z.B.
System.out.println(var.ausgeben()); //Ausgabe = 8.0 weil die Variable von Dir verändert wurde
Variable var3 = var2; //fieser trick var3 zeigt auf var2 (also zeigen beide auf dieselbe Speicheradresse)
System.out.println(var3.ausgeben); //Ausgabe = 7.5 weil var3 auf dieselbe Speicheradresse zeigt wie var2
//noch schlimmer:
var3.setVariable(15.7);
System.out.println(var2.ausgeben); //Ausgabe = 15.7 ja var 3 zeigt auf dieselbe Speicheradresse wie var2 und wenn der Wert an der Speicheradr. von var3 verändert wird, dann auch der von der Speicheradr von var2
}

Erwartest du das dass jemand liest? Benutz die Code Tags.

 

[wiebkes]

Erwartest du das dass jemand liest? Benutz die Code Tags.

Wo du Recht hast, hast Du Recht - Also nochmal in schön und mit Farbe.

Die Konstruktoren werden verwendet.
Gehen wir mal von folgender main-methode aus:

public static void main(String[] args){
Variable var = new Variable();[/COLOR][COLOR=#006400]//Standardkonstruktor wird verwendet[/COLOR][COLOR=#222222]
System.out.println(var.ausgeben()); [/COLOR][COLOR=#006400]//Ausgabe = 0.0 weil der Standardkonstruktor benutzt wird[/COLOR][COLOR=#222222]
Variable var2 = new Variable(7.5); [/COLOR][COLOR=#006400]//Übergabekonstruktor wird verwendet[/COLOR][COLOR=#222222]
System.out.println(var2.ausgeben()); [/COLOR][COLOR=#006400]//Ausgabe = 7.5 weil der Übergabekonstruktor genutzt wird[/COLOR][COLOR=#222222]
var.einlesen(); [/COLOR][COLOR=#006400]// Wert angabe = 8.0 z.B.[/COLOR][COLOR=#222222]
System.out.println(var.ausgeben()); [/COLOR][COLOR=#006400]//Ausgabe = 8.0 weil die Variable von Dir verändert wurde[/COLOR][COLOR=#222222]
Variable var3 = var2; [/COLOR][COLOR=#006400]//fieser trick var3 zeigt auf var2 (also zeigen beide auf dieselbe Speicheradresse)[/COLOR][COLOR=#222222]
System.out.println(var3.ausgeben()); [/COLOR][COLOR=#006400]//Ausgabe = 7.5 weil var3 auf dieselbe Speicheradresse zeigt wie var2
//noch schlimmer:
[/COLOR][COLOR=#222222]var3.setVariable(15.7);
System.out.println(var2.ausgeben()); [/COLOR][COLOR=#006400]//Ausgabe = 15.7 da var 3 zeigt auf dieselbe Speicheradresse wie var2 
//und wenn der Wert an der Speicheradr. von var3 verändert wird, dann auch der von der Speicheradr von var2[/COLOR][COLOR=#222222]
}
[/COLOR]

PS: Irgendwie teilt mir das System meine Code-tags auf und macht davon zwei Code Felder... nicht geplant und auch mehrere Änderungsversuchen war das irgendwie nicht hinzubekommen.

 

[Loooki]

Und wo ist jetzt dien Problem bis auf das es nicht compilieren sollte?

[COLOR=#222222]System.out.println(var3.ausgeben)[/COLOR]

Kann ja so nicht funktionieren, richtig wäre

[COLOR=#222222]System.out.println(var3.ausgeben())[/COLOR]

 

[wiebkes]

Eigentlich hätte das problemfreier Code werden sollen, also mit den Klammern. Der Text sollte mit Kommentaren nur zur Verdeutlichung sein, was wann passiert und wann welcher Konstruktor verwendet wird. Auch wenn es wahrscheinlich für hartloni da eh schon zu spät ist.
Falls es für meinen vorherigen Eintrag noch nicht zu spät ist korrigiere ich den gleich auch nochmal...