Hi,
Das mit oo- Ansatz ist wohl noch neu für dich.
Der Konstruktor von der erweiterten Klasse (in diesem Fall derjenige von SuperClass) wird immer als erster aufgerufen.
In der main- Methode wird zuerst eine Instanz der SuperClass erstellt.
Im Konstruktor von SuperClass wird die Methode: setValue() aufgerufen. Zuerst wird die Instanz von SuperClass() erstellt, dann wird für diese die setValue() Methode aufgerufen, womit Wert von valueA gesetzt wird.
Als nächstes erzeugst du in der main- Methode eine Instanz von SubClass(). Hier wird nun zuerst der Konstruktor von SuperClass() aufgerufen, der wiederum eine Instanz von SuperClass() erzeugt und die Methode setValue() aufruft. Nachdem die Instanz erstellt ist und setValue() aufgerufen wurde, wird eine Instanz von SubClass erzeugt. Nun folgt die Ausgabe der Werte mit System.out.println(..)
Wenn eine Instanz von einer erbenden Klasse erzeugt wird, wird immer eine Instanz von der vererbenden Klasse erzeugt.
Wenn es nicht explizit, wie du es gemacht hast:
[code=Java]
public SubClass(){
super();
}
[/code]
im Code deklariert wurde, wird per default der Standart- Konstruktor von der Klasse SuperClass (vererbenden Klasse) aufgerufen. Der Standart- Konstruktor wird per default immer erstellt. (Auch wenn dieser in der Klasse nicht definiert wurde).
Sobald eine Instanz von einer Klasse existiert, können die Variablen- Werte von dieser Instanz gesetzt bez. gelesen werden. (egal ob dies nun eine erbende oder eine vererbende Klasse ist).
In den Klassen SuperClass und SubClass sind die Variablen valueA und valueB. Dies sind Instanzvariablen und sollten nie public sein.
Diese solltest du private deklarieren. Der Zugriff auf diese Variablen sollte dann mit getters und setters gemacht werden
In etwa so:
[code=Java]
public class SuperClass {
private String valueA;
public SuperClass() {
this.valueA = "a";
}
protected void setValue(String valueA){
this.valueA = valueA;
}
protected String getValueA(){
return valueA;
}
}
[/code]
So ist klar definiert, wie der Wert der Variable valueA gesetzt bzw. zurück gegeben werden kann. Das selbe gilt für die subClass.
In deiner Main- Methode werden nun 3 Instanzen erzeugt (obwohl nur 2 definert wurden).
1. Instanz superclass
2. Im Kontruktor von SubClass wird mit super() eine Instanz von SuperClass erstellt.
3. Instanz subclass
Beide Instanzen von SuperClass sind voneinander komplett unabhängig.
Zu deiner "Frage":
... überhaupt auf die valueB zugreifen kann, wenn diese nicht initialisiert ist....
Beim beim Erzeugen der Instanz SubClass wird zuerst die Instanz der SuperClass erstellt. Der Konstruktor führt dann die Methode setValue() auf. In diesem Fall wird setValue() der Klasse SubClass ausgeführt, da in dieser Klasse die Methode setValue() überschrieben wurde.
Im Code steht: String valueB = null; das heisst. Du erstellst eine Instanz der Klasse String und setzt die Referenz auf null. D.h. für die JVM dass diese Instanz nicht mehr benötigt wird und irgendwann mal von der GarbageCollection entfernt wird.
Soblad die Method setValue() in der SubClass nun aufgerufen wird, möchte diese Methode in die String- Variable valueB etwas schreiben. Da diese aber eine ungültige Referenz hat (also null) wird die Zuweisung: this.valueB = "B"; nichts bewirken. Deshalb bekommst du auch: someThing null zurück. Wie du geschrieben hast, funktioniert es mit String valueB; Hier wird eine gültige Referenz erstellt und an diese Referenz kann ein Wert zugewiesen werden.
So wie in der main- Methode zu sehen ist, ist es dein Ziel, den Wert der SuperClass- Instanz, welche mit super() erstellt wurde zu erhalten.
Vielleicht ist folgender Code hilfreich
[code=Java]
public class SuperClass {
private String value;
public SuperClass(){
}
protected void setValue(String value){
this.value = value;
}
protected String getValue(){
return value;
}
}
[/code]
[code=Java]
public class SubClass extends SuperClass{
String value = null;
public SubClass(){
super();
}
@Override
protected void setValue(String value){
this.value = value;
}
@Override
protected String getValue(){
return value;
}
public void setValueOfSuperClass(String value) {
super.setValue(value);
}
public String getValueOfSuperClass() {
return super.getValue();
}
}
[/code]
[code=Java]
public class Main {
public static void main(String[] args) {
String valueA = "a";
String valueB = "b";
String valueAb = "ab";
SuperClass superclass = new SuperClass();
SubClass subclass = new SubClass();
superclass.setValue(valueA);
subclass.setValue(valueB);
subclass.setValueOfSuperClass(valueAb);
System.out.println(superclass.getValue());
System.out.println(subclass.getValueOfSuperClass() + " " + subclass.getValue());
}
}
[/code]
