Vererbung Setzen auf Null bei Subklassen

[xasz]

Hallo Leute,

ich hatte heute ein langwieriges Problem und bin letzten Endes auf die Lösung gekommen.
Leider versteh ich den Code nicht ganz und wollte hier mal fragen, ob mir das einer erklären kann.

Ich habe hier mal ein Beispiel vorbereitet:

public class Main {

	public static void main(String[] args) {
		SuperClass superclass = new SuperClass();
		SubClass subclass = new SubClass();
		System.out.println(superclass.getValueA());
		System.out.println(subclass.getValueA() + " " + subclass.getValueB());
	}
}

public class SuperClass {
	String valueA = "a";
	public SuperClass(){
		setValue();
	}
	protected void setValue(){
		this.valueA = "a";
	}
	public String getValueA(){
		return this.valueA;
	}
}

public class SubClass extends SuperClass{
	String valueB = null;
	public SubClass(){
		super();	
	}
	@Override
	protected void setValue(){
		this.valueA = "someThing";
		this.valueB = "B";
	}
	public String getValueB(){
		return this.valueB;
	}
}

Meine Ausgabe ist diese hier:

a
someThing null

Wenn ich in der Subclass einfach

String valueB;

Funktioniert der Code.

Mein Problem ist, dass nach meinem Verständnis erst die Attribute der Subclass erstellt werden und dann der Konstruktor kommt. Dies scheint aber wohl nicht so zu sein, kann ich mit dem Debugger nachvollziehen. Allerdings versteh ich auch nicht ganz, wie die überschriebene Methode setValue wenn ich die Subklasse aufrufe und din der Superklasse ausgeführt wird, überhaupt auf die valueB zugreifen kann, wenn diese nicht initialisiert ist.

Komischer Satz, ich hoffe man versteht es.

Ich danke euch schonmal für eine Erklärung.

 

[knilch]

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:

public SubClass(){
        super();   
    }

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:

public class SuperClass {
    private String valueA;
    
    public SuperClass() {
    	this.valueA = "a";
    }
    
    protected void setValue(String valueA){
        this.valueA = valueA;
    }
   
    protected String getValueA(){
        return valueA;
    }
}

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

public class SuperClass {
    private String value;
    
    public SuperClass(){
    }
   
    protected void setValue(String value){
        this.value = value;
    }
   
    protected String getValue(){
        return value;
    }
}

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();
    }  
}

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());
    }
}

 

[xasz]

Wow, dank für deine ausführliche Antwort :toll:
Tut mir leid, dass ich das jetzt wieder ausgrabe, aber bin irgendwie nicht dazu gekommen. Wollte aber für so eine Klasse Arbeit, das Danke nicht fehlen lassen!