Komposition an Stelle von Vererbung

Komposition anstelle von Vererbung (engl. 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]

Das Diagramm stellt dar, wie das Fliege- und Redeverhalten durch Komposition flexibel gestaltet werden kann.[1]

Grundlagen

Bei diesem Entwurfsprinzip werden Algorithmen, die in einer Klasse Verwendung finden können, als separate Klassen entworfen, die vorzugsweise 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. Dadurch sind die Klassen von den Algorithmen und deren Details getrennt – weitere Entwicklungen und Änderungen an den Algorithmenklassen haben kaum Einfluss auf die Klasse, was Anpassungen unnötig macht. Dadurch wird der Code nicht verändert, was wiederum ein anderes Entwurfsprinzip, das Open-Closed-Prinzip, befürwortet.[1]

Beispiel

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

/**
 * Interface for everything flyable
 *
 */
public interface Flyable {
    /**
     * Method that implements flying behaviour
     */
    void fly();
}
/**
 * Interface for everything that gives a quacking sound
 *
 */
public interface Quackable {
    /**
     * Method for the quacking sound
     */
    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;
    }
}

Siehe auch

Objektorientierter Entwurf

Einzelnachweise

Eric Freeman, Elisabeth Freeman, Sierra Kathy, Bates Bert: Mike Hendrickson (Hrsg.): Mike Loukides (Hrsg.): Head First Design Patterns (English, paperback), Band 1, O'REILLY, 2004, ISBN 978-0-596-00712-6, S. 23 (Abgerufen am 24. September 2012).

This article is issued from Wikipedia. The text is licensed under Creative Commons - Attribution - Sharealike. The authors of the article are listed here. Additional terms may apply for the media files, click on images to show image meta data.

[HFDPs-1] Eric Freeman, Elisabeth Freeman, Sierra Kathy, Bates Bert: Mike Hendrickson (Hrsg.): Mike Loukides (Hrsg.): Head First Design Patterns (English, paperback), Band 1, O'REILLY, 2004, ISBN 978-0-596-00712-6, S. 23 (Abgerufen am 24. September 2012).