Java Übung & Lösung: Variablen anlegen und Zugriff im Java Programm
In dieser Java Übung soll der Unterschied zwischen Instanz- und Klassenvariablen demonstriert werden.
Außerdem werde ich dir den Zugriff über Methoden zeigen.
- Lege dazu eine Klasse Variablenzugriff an.
- Deklariere eine Instanzvariable, namens „zaehlerInstanz“.
Der Wertebereich dieser Variablen soll eine ganze Zahl sein. - Deklariere eine zweite Variable.
Diese soll allerdings eine Klassenvariable sein.
Nenne diese „zaehlerKlasse“.
Der Datentyp soll ebenfalls dem einer ganzen Zahl entsprechen. - Im parameterlosen Konstruktor der Klasse „Variablenzugriff“ sollen beide Variablen um eins erhöht werden.
- Außerdem sollen in der Klasse drei Methoden implementiert werden.
- Die Instanzmethode „zaehleInstanz“ soll den Wert der Instanzvariable zurückgeben.
- Die zweite Methode ist eine statische Methode, namens „zaehleKlasse“.
Diese gibt dann den Wert der Klassenvariable zurück. - Die dritte Methode ist die main-Methode.
Innerhalb der main-Methode werden zwei Objekte der Klasse erzeugt.
Nenne diese Objekte „zaehlerEins“ und „zaehlerZwei“.
An diesen Objekten kannst du dann die Instanzmethode „zaehleInstanz“ aufrufen. - Die main-Methode führt außerdem die zweite Methode „zaehleKlasse“ aus.
- Lass dir die Rückgabewerte der Methoden auf der Konsole anzeigen.
- Welchen Rückgabewert hat die Instanzvariable für das erste Objekt?
- Welchen Rückgabewert hat die Instanzvariable für das zweite Objekt?
- Welchen Rückgabewerte hat die Klassenvariable nachdem beide Objekte erzeugt wurden?
So sieht die Lösung zu dieser Java Übung aus.
Als Erstes legst du die Klasse an.
Achte beim Klassennamen auf die Namenskonvention. (VariablenZugriff)
Innerhalb der Klasse legst du dann die beiden Variablen und den parameterlosen Konstruktor an.
Und so sieht der Code aus.
public class VariablenZugriff {
int zaehlerInstanz; //Objektvariable vom Datentyp Integer
static int zaehlerKlasse; // Klassenvariable vom Datentyp Integer
public VariablenZugriff(){ //parameterloser Konstruktor
zaehlerInstanz=zaehlerInstanz+1; //Instanzvariable wird um eins erhöht
zaehlerKlasse=zaehlerKlasse+1; //Klassenvariable wird um eins erhöht
}
}Als nächstes kannst du die Instanzmethode „zaehleInstanz“ und „zaehleKlasse“ implementieren.
public class VariablenZugriff {
int zaehlerInstanz; //Objektvariable vom Datentyp Integer
static int zaehlerKlasse; // Klassenvariable vom Datentyp Integer
int zaehleInstanz(){ //Objektmethode mit Rückgabetyp Integer
return zaehlerInstanz; //Rückgabe der Objektvariable
}
static int zaehleKlasse(){ //Klassenmethode Rückgabetyp Integer
return zaehlerKlasse; //Rückgabe der Klassenvariable
}
public VariablenZugriff(){//parameterloser Konstruktor
zaehlerInstanz=zaehlerInstanz+1;//Instanzvariable wird um eins erhöht
zaehlerKlasse=zaehlerKlasse+1;//statische Variable wird um eins erhöht
}
}Im nächsten Schritt implementierst du noch die main-Methode.
Dann erzeugst du beide Objekte.
Innerhalb der Klammern der System.out.println()-Anweisung findet der jeweilige Methodenaufruf statt.
public class VariablenZugriff {
int zaehlerInstanz; //Instanzvariable vom Datentypen Integer
static int zaehlerKlasse; // statische Variable vom Datentyp Integer
int zaehleInstanz(){ //Objektmethode mit Rückgabetyp Integer
return zaehlerInstanz; //Rückgabe der Objektvariable
}
static int zaehleKlasse(){ //Klassenmethode Rückgabetyp Integer
return zaehlerKlasse; //Rückgabe der Klassenvariable
}
public VariablenZugriff(){//parameterloser Konstruktor
zaehlerInstanz=zaehlerInstanz+1;//Instanzvariable wird um eins erhöht
zaehlerKlasse=zaehlerKlasse+1;//statische Variable wird um eins erhöht
}
public static void main(String[] args) {
VariablenZugriff zaehlerEins = new VariablenZugriff();//Objekt zaehlerEins wird erzeugt
VariablenZugriff zaehlerZwei = new VariablenZugriff();//Objekt zaehlerZwei wird angelegt
System.out.println(zaehlerEins.zaehleInstanz());//Konsolenausgabe für Objekt zaehlerEins
System.out.println(zaehlerZwei.zaehleInstanz());//Konsolenausgabe für Objekt zaehlerZwei
}
}Jetzt kannst du die ersten beiden Fragen zur Aufgabe beantworten.
Die Instanzvariablen für die Objekte „zaehlerEins“ und „zaehlerZwei“ ist jeweils Eins.
Kommen wir zur statischen Variable.
public class VariablenZugriff {
int zaehlerInstanz; //Instanzvariable vom Datentypen Integer
static int zaehlerKlasse; // statische Variable vom Datentyp Integer
int zaehleInstanz(){ //Objektmethode mit Rückgabetyp Integer
return zaehlerInstanz; //Rückgabe der Objektvariable
}
static int zaehleKlasse(){ //Klassenmethode Rückgabetyp Integer
return zaehlerKlasse; //Rückgabe der Klassenvariable
}
public VariablenZugriff(){//parameterloser Konstruktor
zaehlerInstanz=zaehlerInstanz+1;//Instanzvariable wird um eins erhöht
zaehlerKlasse=zaehlerKlasse+1;//statische Variable wird um eins erhöht
}
public static void main(String[] args) {
VariablenZugriff zaehlerEins = new VariablenZugriff();//Objekt zaehlerEins wird erzeugt
VariablenZugriff zaehlerZwei = new VariablenZugriff();//Objekt zaehlerZwei wird angelegt
System.out.println(zaehlerEins.zaehleInstanz());//Konsolenausgabe für Objekt zaehlerEins
System.out.println(zaehlerZwei.zaehleInstanz());//Konsolenausgabe für Objekt zaehlerZwei
System.out.println(zaehleKlasse());//Konsolenausgabe der statischen Variablen
}
}Die statische Variable hat den Wert zwei.
Worin besteht der Unterschied zwischen den Variablen?
Du hast innerhalb der main Methode zwei Objekte angelegt.
Du hast somit zweimal den parameterlosen Konstruktor aufgerufen.
Im Konstruktor wurde somit zweimal der Wert der Instanzvariable um eins erhöht.
Doch der Wert war für beide Instanzen jeweils eins?
Warum?
Jedes Objekt hat seine eigene Instanzvariable.
Das bedeutet, dass die Variable „zaehlerInstanz“ für das Objekt „zaehlerEins“ eine ganz andere ist, als für „zaehlerZwei“.
Du kannst somit für jedes Objekt die Instanzvariable unterschiedlich belegen.
Jede Instanzvariable kann je nach Objekt einen unterschiedlichen Wert zugewiesen bekommen.
Somit ist es möglich zum Beispiel Menschobjekte mit unterschiedlichen Größen, Gewichten usw. anzulegen.
Bei den Klassenvariablen funktioniert dies nicht.
Du hast gesehen, dass wir diese Variable im Konstruktor erhöht haben.
Und diese Variable beträgt zwei.
Falls du jetzt noch mehr Objekte anlegst, wird der Konstruktor öfter aufgerufen.
Dadurch könnte der Wert der Klassenvariable auf drei, vier usw. steigen.
Somit wird klar, dass Klassenvariablen nicht objektspezifisch sind.
Klassenvariablen stehen allen Objekten zur Verfügung.
Die vielseitigen Möglichkeiten für den Einsatz von Klassenvariablen habe ich in einem Beitrag beschrieben.
Falls du jetzt Lust hast mehr über Variablen zu erfahren, dann besuche die Übersichtsseite zu den Java-Variablen.
Über den Autor
