OOP PropertyChangeListener - Vererbung oder Komposition?

[membersound]

Hallo,

ich habe einige Klassen, in denen ich PropertyChangeListener verwenden will. Jetzt frage ich mich, ob man das besser mit Vererbung oder Komposition realisiert?

Nachteil bei der Vererbung wäre ja, dass diese Klassen dann von nirgendwo anders mehr erben könnten.
Außerdem soll eine Vererbung ja immer eine "is-a" Beziehung sein. Und ein Auto ist ja kein PropertyChangeSupport. Da würde man die Vererbung ja in gewisser Weise missbrauchen, oder?

Beispiel:

public class BaseListener {
    protected PropertyChangeSupport propertyChangeSupport = new PropertyChangeSupport(this);
 
    public void addPropertyChangeListener(PropertyChangeListener listener) {
        propertyChangeSupport.addPropertyChangeListener(listener);
    }
 
    public void removePropertyChangeListener(PropertyChangeListener listener) {
        propertyChangeSupport.removePropertyChangeListener(listener);
    }
}
 
//inheritance
public class Auto extends BaseListener {
    public void setData(String data) {
        String oldData = this.data;
        this.data = data;
        propertyChangeSupport.firePropertyChange("data", oldData, data);
    }
}

//composition
public class Auto {
    public void setData(String data) {
        String oldData = this.data;
        this.data = data;
        new BaseListener().propertyChangeSupport.firePropertyChange("data", oldData, data);
    }
}

 

[turtle]

ich habe einige Klassen, in denen ich PropertyChangeListener verwenden will. Jetzt frage ich mich, ob man das besser mit Vererbung oder Komposition realisiert?

Komposition.

Und ein Auto ist ja kein PropertyChangeSupport. Da würde man die Vererbung ja in gewisser Weise missbrauchen, oder?

Eben.

public class Auto {
	private String data;
	private PropertyChangeSupport pcs = new  PropertyChangeSupport(this);

	   public void setData(String data) {
	        String oldData = this.data;
	        this.data = data;
	        pcs.firePropertyChange("data", oldData, data);
	    }
}

 

[membersound]

Danke.

Und was mache ich mit den property Methoden?
Muss ich in jeder Klasse dann einzeln schreiben:

    public void addPropertyChangeListener(PropertyChangeListener listener) {
        propertySupport.addPropertyChangeListener(listener);
    } 
    public void removePropertyChangeListener(PropertyChangeListener listener) {
        propertySupport.removePropertyChangeListener(listener);
    }

?

 

[turtle]

Einzeiler einfügen, Du armes Haschi-Pusch :lol:

In Eclipse kannst Du auch selber Templates erweitern und dann sinds nur wenige Tastendrücke😉

 

[membersound]

Schon klar, dass das kein großes Ding ist.
Aber ich versuch auch im Kleinen doppelten Code zu vermeiden. Dachte man könnte das halt irgendwie so designen, dass es wiederverwertbar ist.

 

[turtle]

Wie Du ja schon angemerkt hast, ist Inheritance vielleicht keine gute Idee, wenn Du das in eine andere Objekt-Hierarchie einbauen möchtest.

Dann muss ja irgendein Objekt z.B. addPropertyChangeListener aufrufen. Dieses kannst Du mehrmals eingeben oder Dir zum Beispiel eine Helper-Klasse schreiben, die das dann tut. Aber immer musst Du diese Methode aufrufen oder halt die Wrapper-Klasse bemühen.

Aber eine Zeile gegen eine andere tauschen? Wo ist da der Sinn? Ich glaube man kann das DRY-Prinzip auch über-strapazieren.