Komposition an Stelle von Vererbung

aus Wikipedia, der freien Enzyklopädie
Wechseln zu: Navigation, Suche
Das Diagramm stellt dar, wie das Fliege- und Redeverhalten durch Komposition flexibel gestaltet werden kann.[1]

Komposition an Stelle von Vererbung (englisch composition over inheritance oder composite reuse principle) ist eine Technik im Softwareentwurf. Durch dieses Prinzip werden Klassen entkoppelt, was zu flexibleren und stabileren Entwürfen führt. So ist es möglich, zur Laufzeit das Verhalten einer Klasse zu verändern.[1]

Grundlagen[Bearbeiten]

Um dieses Entwurfsprinzip anzuwenden werden Algorithmen, die in einer Klasse Verwendung finden können als separate Klassen entworfen, die vorzüglich von Schnittstellen abgeleitet sind. Die Klassen, die eventuell einen dieser Algorithmen ausführen sollen, beinhalten eine Membervariable des Typs der gemeinsamen Schnittstelle, der (auch zur Laufzeit) einer dieser Algorithmen zugewiesen werden kann. Auf diese Art und Weise sind die Klassen von den Algorithmen und deren Details getrennt - weitere Entwicklungen und Änderungen an den Algorithmenklassen haben kaum Einfluss auf die Klasse, was unnötige Anpassungen hinfällig macht. Dadurch wird der Code nicht verändert, was wiederum ein anderes Entwurfsprinzip, das Open-Closed Prinzip, befürwortet.[1]

Beispiel[Bearbeiten]

Das folgende Java-Beispiel ist die Implementierung des oben angegebenen Entwurfs.

/**
 * Interface for everything flyable
 *
 */
public interface Flyable {
    /**
     * Method that implements flying behaviour
     */
    public void fly();
}
/**
 * Interface for everything that gives a quacking sound
 *
 */
public interface Quackable {
    /**
     * Method for the quacking sound
     */
    public void quack();
}
/**
 *
 */
public abstract class Duck implements Ducklike, Comparable<Object> {
    /** Flying behaviour of the duck */
    protected Flyable flyBehavior = null;
    /** Quack behaviour of the duck */
    protected Quackable quackBehavior = null;
 
    /**
     * Standard constructor
     */
    public Duck() {
        initialize();
    }
 
    /**
     * Constructor
     * @param WEIGHT Weight of the duck
     */
    public Duck(final float WEIGHT) {
        initialize();
        weight = WEIGHT;
    }
 
    protected abstract void initialize();
 
    /**
     * Display method
     */
    public abstract void display();
 
    /**
     * Performs the flying behaviour
     */
    public void fly() {
        flyBehavior.fly();
    }
 
    /**
     * Performs the quacking behaviour
     */
    public void quack() {
        quackBehavior.quack();
    }
 
    /**
     * Setter for the fly behaviour
     * @param FLYING
     */
    public void setFlyBehavior(final Flyable FLYING) {
        flyBehavior = FLYING;
    }
 
    /**
     * Setter for the quack behaviour
     * @param QUACKING
     */
    public void setQuackBehavior(final Quackable QUACKING) {
        quackBehavior = QUACKING;
    }
}

Hinweise[Bearbeiten]

  1. a b c Eric Freeman, Elisabeth Freeman, Sierra Kathy, Bates Bert: Head First Design Patterns. (paperback) 1, 2004. Abgerufen am 24. September 2012.

Siehe auch[Bearbeiten]