OOP | Code-Inside Blog

HowTo: Interfaces/Schnittstellen verstehen – mal auf simple Art und Weise

28. Nov, 2007 by Robert Mühsig 15 Kommentare

In dem HowTo geht es um ein sehr simples Thema, womit aber besonders Einsteiger in der Programmierung Probleme haben: Wozu sind Schnittstellen/Interfaces gut? Man kann doch auch genauso gut von einer Klasse erben – also wozu der Spaß und wo kann man das sinnvoll einsetzen?

Wir machen das sehr kurz und schmerzlos an einem “praktischen” Beispiel aus der Natur

In unserem sehr einfachen Beispiel wollen wir bestimmte Klasse (Train, Car, Human) erstellen welche beweglich sind (IMovable) – jedoch bewegt sich ja alles auf eine unterschiedliche Art und Weise, daher ist das unsere Schnittstelle.
Jetzt gehen wir mal davon aus, dass es einen Gott (God) gibt, dann kann der auch ohne Probleme ein bewegliches Objekt “anstupsen”. Genau das wollen wir jetzt implementieren – wie gesagt, sehr praxisnah .

Konsolenprojekt Struktur:

Das wichtigste ist erstmal unser Interface “IMovable” (Schnittstellen werden in .NET immer mit einem I davor geschrieben):

    public interface IMovable
    {
        void Move();
    }

Die Schnittstelle legt nur fest, welche Methoden, Eigenschaften oder Events etwas hat – wie dies jeweils implementiert ist entscheidet dann die Klasse.

    public class Human : IMovable
    {
        #region IMovable Member

        public void Move()
        {
            Console.WriteLine("Der Mensch macht einen Schritt vor.");
        }

        #endregion
    }

Unser Mensch kann einen Schritt vor dem anderen machen – unser Zug fährt zum nächsten Bahnhof und unser Auto nur zur nächsten Ampel. In den einzelnen Klassen kann man nun die Methode implementieren wie man mag – wichtig ist nur, dass die Signatur (also Rückgabetyp, Parameter & Name) gleich bleibt.

Jetzt wollen wir unseren Gott implementieren, welcher Objekte “anstupsen” kann. Allerdings wollen wir nicht X Methoden erstellen, die in dieser Form sind “MoveObject(Human human)”, weil wir noch nicht genau wissen, was sonst noch für bewegliche Klassen hinzukommen.

Hier kommt jetzt unser Interface zum Einsatz:

    public class God
    {
        public static void MoveObject(IMovable item)
        {
            Console.WriteLine("Ein bewegliches Objekt wird bewegt...");
            item.Move();
        }
    }

Die Methode “MoveObject” nimmt einfach “irgendwas” was “IMovable” impementiert – egal ob es ein Auto, Zug oder Mensch ist.
Allerdings kann man in dieser Version jetzt nur auf die Methoden, Eigenschaften etc. zugreifen, welche in der Schnittstelle definiert sind:

Wenn man jetzt beim Auto noch eine spezial Methode implementiert hat, welche man unbedingt dort aufrufen will, muss man casten und über GetType prüfen, ob das Objekt von Typ “Car” ist – aber das geht zu weit und ist jetzt erstmal kein Thema hier.

Der Hauptvorteil jetzt liegt darin, dass unsere “MoveObject” Methode keine Ahnung haben braucht, was “item” einfach ist – hauptsache es ist beweglich. Was beweglich bei diesem Objekt heisst, ist dieser Methode egal.

Unser kleines Programm testen:

    class Program
    {
        static void Main(string[] args)
        {
            Car BMW = new Car();
            Train ICE = new Train();
            Human Robert = new Human();

            God.MoveObject(BMW);
            God.MoveObject(ICE);
            God.MoveObject(Robert);

            Console.ReadLine();
        }
    }

Wir haben ein BMW, ein ICE und mich – und diese bewegt unser Gott natürlich. Resultat:

So – alle unsere 3 Objekte bewegen sich anders und es wird angezeigt. Jetzt kann man noch weitere Klassen hinzufügen, welche ebenfalls “IMovable” implementieren und wir brauchen die God.MoveObject Methode nicht anpassen.

Olé

PS: Nein, ich bin nicht religös, brauchte aber ein einfaches Beispiel.

[ Download Source Code ]

Buchempfehlung: Entwufsmuster von Kopf bis Fuß

20. Nov, 2007 by Robert Mühsig Kein Kommentar

Entwufsmuster sind immer ein Thema in der Softwarearchitektur, allerdings gibt es zwar das wunderbare Standardwerk von der Gang of Four, leider ist das dort etwas arg trocken beschrieben und besonders als Nachmittagsliteratur schwer verdaulich.
Wer trotzdem gerne ein Buch über Entwufsmuster haben möchte, welche diese zudem sehr detailiert und mit (Java)-Beispielcode erlernen will, dem empfehle ich das “Entwurfmuster von Kopf bis Fuß” Buch.

Besonders hervorzuheben sind dabei folgende Punkte:

Der Schreibstil ist angenehm locker und auch viele Zeichnungen / Konzeptionen etc. kommen zum Einsatz, dadurch erhöht sich wirklich der Spaß am lesen.
Die wesentlichen Entwurftmuster werden gut und sehr verständlich Schritt für Schritt erklärt. Dabei werden auch Risiken oder “Nebenwirkungen” genannt.
Um mal viele Entwurfsmuster in einem Demoprojekt zu sehen, gibts zum Ende des Buches ein kleines Beispiel mit Enten
Der Beispielcode ist in Java geschrieben, allerdings kann man das auch gut auf .NET / C# mappen, sodass es da zu keinen Schwierigkeiten kommt
Das Buch ist eigentlich für jeden Software Entwickler gut geeignet, da es sehr verständlich und praxisorientiert ist – zudem gefällt mir sehr gut der Schreibstil und die gesamte Machart des Buches .

[ Amazon Link ]

HowTo: Objektorientierte Programmierung / OOP in Javascript (Eine einfache Klasse erstellen)

16. Nov, 2007 by Robert Mühsig 5 Kommentare

Durch den (berechtigten) Hype um AJAX und das “Daten-Format” JSON wird eine Sache in der Webentwicklung immer interessanter: Die Javascriptentwicklung.

Insgesamt vollzieht sich meiner Meinung nach ein kleiner Wandel in der Webentwicklung – man versucht sehr viele Sachen auf den Client auszuführen. Diese Entwicklung kann ich nur begrüßen, denn warum muss ich bei einer Sortierung von einer Tabelle wieder mit den Server kommunizieren, obwohl die Daten bereits auf dem Client sind?

Genau solche Aufgaben können heute bereits Javascript-Frameworks erledigen. Auch bei Microsofts ASP.NET AJAX Extensions ist eine Clientbibliothek enthalten, doch nun kommen wir zur generellen Frage: Wie kann ich Daten in so einem Framework kapseln? Wie kann ich eigene Javascript Klassen mit Methoden definieren?

Klassen und Methoden in Javascript definieren – Schlagwort “prototype”

Prototype ist nicht nur ein Javascript Framework, sondern auch allgemein in der JS Welt ein Schlüsselwort für das definieren von Methoden. Aber erstmal Schritt für Schritt.
Wir machen ein ganz einfaches Beispiel – ein Rechteck. Das als Eigenschaft eine Höhe und Breite und wir möchten nun den Flächeninhalt berechnen.

Schritt 1: Konstruktor samt Member definieren

    function Rectangle()
    {
        this.height;
        this.width;
    }

Der Konstruktor ist eigentlich eine ganz normale JS Funktion, denn es gibt kein Schlüsselwort “class” in JS. Dannach sagen wir noch, dass wir zwei Eigenschaften height und width haben und schreiben noch (wie in der OOP üblich) ein “this” davor.

Schritt 2: Getter / Setter definieren

Wir können natürlich die Werte auch direkt dem Konstruktor übergeben (”Rectangle(10, 5)”), aber wir machen das direkt mit Getter/Setter-Methoden, wo auch das “prototype” zum Tragen kommt:

    Rectangle.prototype.setHeight = function(value)
    {
            this.height = value;
    }
    Rectangle.prototype.getHeight = function()
    {
            return this.height;
    }

Wir “prototypen” das Rectangle und sagen, ass es eine “setHeight” und “getHeight” Funktion gibt, welche über das Schlüsselwort “this” Zugang zu den Eigenschaften der Klasse haben.
Das ganze natürlich auch noch für die andere Eigenschaft.

Schritt 3: Calc Methode erstellen

Die Methode wo wir die Fläche errechnen wollen ist genauso einfach geschrieben wie bereits vermutet. “prototype” und über “this” auf die Werte zugreifen:

    Rectangle.prototype.calc = function()
    {
            var result = this.getWidth() * this.getHeight();
            return result;
    }

Schritt 4: Objekte erstellen und testen

In der ganz einfachen Demoanwendung (siehe Link unten) erstellen wir unsere Obejekte in einer JS Funktion welche im onload aufgerufen wird.

    function initApp()
    {
        var objectA = new Rectangle();
        objectA.setHeight(10);
        objectA.setWidth(2);

        var objectB = new Rectangle();
        objectB.setHeight(15);
        objectB.setWidth(3);

        alert(objectA.calc());
        alert(objectB.calc());
    }

Schritt 5: Ergebnis

Funktioniert wunderbar (getestet IE7 und FF2):

Ein Blick in den Firebug zeigt uns auch die Hierarchie:

Weiterführende Links

Ich wollte dieses Beispiel ganz bewusst simple halten, da ich ansonsten immer nur sehr komplexe Beispiele gesehen hab. Wer sich tiefergehender darüber informieren möchte, der sollte sich diese Seite mal anschauen.

[ Source Code + Demoanwendung ]