Tutorials

Wir hatten uns im 1.Teil mit dem Objekt selbst beschäftigt. Dabei ist mir ein kleiner Fehler unterlaufen. Ich habe ganz einfach die Konstruktoren vergessen. Über den Konstruktor wird ein Objekt erzeugt. Es gibt mehrere Möglichkeiten diesen einzusetzen. Als Standard ist bereits ein Konstruktor aktiv. Dieser wird vom Compiler selbst erzeugt. Aber auch nur dann wenn kein eigener Konstruktor in der Klasse steht. Diesen Konstruktor haben wir im 1.Teil bereits mehrfach eingesetzt.

Dim p As New Person

Dieser Aufruf ruft den Konstruktor "new()" auf, der automatisch vom Compiler in der Klasse Person erzeugt wurde. Schauen wir uns also noch einmal die Klasse Person komplett an und erweitern diese Klasse um einen oder mehrere Konstruktoren. Es gibt natürlich auch das Gegenteil, die sogenannten Destruktoren, aber darüber werden wir später reden.

''' <summary>
''' Öffentliche Klasse Person
''' </summary>
Public Class Person

    ''' <summary>
    ''' Enum mit der Auswahl des Geschlechts
    ''' </summary>
    Public Enum Sexes
        ''' <summary>
        ''' männlich
        ''' </summary>
        Male
        ''' <summary>
        ''' weiblich
        ''' </summary>
        Female
    End Enum

    Private _Gender As Sexes = Sexes.Female

    ''' <summary>
    ''' Setzt das Geschlecht einer Person oder gibt es zurück. Default = Weiblich.
    ''' </summary>
    ''' <returns>Das Geschlecht einer Person</returns>
    Public Overridable Property Gender As Sexes
        Get
            Return _Gender
        End Get
        Set(value As Sexes)
            _Gender = value
        End Set
    End Property

    Private _Weight As Integer

    ''' <summary>
    ''' Eigenschaft Gewicht. Setzt das Gewicht in Gramm oder gibt es in Gramm zurück.
    ''' </summary>
    ''' <returns>Gibt das Gewicht in Gramm zurück</returns>
    Public Property Weight As Integer
        Get
            Return _Weight
        End Get
        Set(value As Integer)
            _Weight = value
        End Set
    End Property

    Private _Size As Integer

    ''' <summary>
    ''' Eigenschaft Groesse. Setzt die Größe in Zentimeter oder gibt es in Zentimeter zurück.
    ''' </summary>
    ''' <returns>Gibt die Größe in Zentimeter zurück</returns>
    Public Property Size As Integer
        Get
            Return _Size
        End Get
        Set(value As Integer)
            _Size = value
        End Set
    End Property

    Private _Age As Integer

    ''' <summary>
    ''' Das Alter der Person
    ''' </summary>
    ''' <returns></returns>
    ''' <exception cref="System.ArgumentOutOfRangeException">Wird ausgelöst, wenn das Alter kleiner 0 und größer 150 ist.</exception>
    Public Property Age As Integer
        Get
            Return _Age
        End Get
        Set(value As Integer)
            If value >= 0 AndAlso value <= 150 Then
                _Age = value
            Else
                Throw New ArgumentOutOfRangeException("value", "Das Alter kann nur zwischen 0 und 150 liegen.")
            End If
        End Set
    End Property

    ''' <summary>
    ''' Erhöht das Alter um 1, wenn das Alter >= 0 ist
    ''' </summary>
    ''' <returns>True, wenn das Alter erfolgreich erhöht wurde, sonst false</returns>
    Public Function IncreasingAge() As Boolean
        If Age >= 0 Then
            Age = +1
            Return True
        Else
            Return False
        End If
    End Function
End Class

Wir erweitern diese Klasse um folgenden Code. Diesen Schreiben wir zwischen die Propertys und die Funktionen.

    ''' <summary>
    ''' Erzeugt eine Person als Objekt
    ''' </summary>
    Public Sub New()

    End Sub

Dies erzeugt einen Konstruktor, der durch "Dim p as new Person()" automatisch aufgerufen wird. Wir können auch mehrere Konstruktoren schreiben.

Seid ihr auch schon einmal über den Begriff Objektorientierte Programmierung gestolpert? Kennt ihr die Programmierung als Abfolge von Befehlen und wollt jetzt mit Objekten einen anderen vielleicht besseren Ansatz verfolgen? Was hat das mit der Abfolge noch zu tun? Was bringen mir denn Objekte und was kann ich mit ihnen machen? Wenn ihr euch solche Fragen stellt, dann seid ihr hier genau richtig. Denn ich werde euch den Unterschied an Beispielen erklären.

Warum Objektorientiert?

Bisher wurde der eher prozedurale Ansatz gewählt. Man schreibt eine Prozedur und hüpft zur Not im Code herum. Die Objektorientierung möchte dagegen das Problem so abbilden, wie es schon bei der Planung der Anwendung oft getan wird. Man erstellt einen Ablaufplan mit detailierten Objekten und verbindet diese durch Linien. Damit will man Abhängigkeiten, Zugehörigkeiten abbilden. Umgesetzt wird es dann tatsächlich aber nicht so sauber. Mit Objekten kann man diese Dinge direkt umsetzen. Um das mal ganz kurz zu umreisen. Angenommen du möchtest eine Stadt programmieren, die mit Menschen bevölkert ist. Dann wirst du mit dem prozeduralen Ansatz das Problem lösen können. Aber ist es auch elegant? Mit Objekten löst man das Problem so... Stadt->Stadtteil->Straße->Haus->Wohnung->Personen->Person. Jeder der hier aufgeführten Begriffe sind dann die entsprechenden Objekte. Und die Pfeile zeigen die Richtung, wie du in der Stadt Köln zu Max Mustermann kommst. Und vielleicht kannst du sogar direkt Stadt->Max Mustermann aufrufen, weil das Objekt Person transparent verfügbar ist oder weil Stadt seine Eigenschaften an die anderen Objekte einfach vererbt.

Was ist ein Objekt?

Und jetzt muss ich ganz kurz unterbrechen. Ich werde jetzt 2 Wörter verwenden, das deutsche Wort Objekt und das englische Pedant Object. Wenn ich vom englischen Wort rede, dann ist tatsächlich das Object aus der Programmiersprache VB.Net gemeint.

Ein Objekt kann alles sein. Streng genommen sind in jeder Sprache, die OO unterstützt, selbst String, Integer, Boolean usw. Objekte, also die einfachsten Datentypen. Doch diese Datentypen besitzen in VB keine direkten Eigenschaften (Propertys). Trotzdem kann man sie als Object darstellen. Das Object ist die niedrigste Form der Objekte. Die Klasse Object in .Net VB enthält nur wenige Funktionen, die dann für alle erbenden Klassen gelten. Zur Vererbung später mehr.

Objekte Grundlagen

Wenn du dich so anschaust, dann hast du bestimmte Eigenschaften. Du hast wenigstens eine Größe und du hast ein Gewicht. Mindestens dies, zeichnet dich aus. Also bist du ein Objekt mit einer Größe und mit einem Gewicht. Auch dein Nachbar hat eine Größe und auch er hat ein Gewicht. Und wenn du in Hamburg wohnst, dann hast du eine Adresse in Hamburg und dein Nachbar hat auch eine ähnliche Adresse. Ein Mensch aus Bayern, der dich und deinen Nachbarn nicht kennt, würde dich im ersten Schritt als Person bezeichnen. Wenn er dich gesehen hat, dann bezeichnet er dich als Person mit Größe X und Gewicht Y. Er gibt dir Eigenschaften. So ist es auch bei der OO Programmierung. Versuchen wir das im Detail. Wir erstellen eine Klasse Person und weisen ihr 3 Eigenschaften zu. Einmal die Größe(Size), das Gewicht(Weight) und das Alter(Age).

''' <summary>
''' Öffentliche Klasse Person
''' </summary>
Public Class Person

    ''' <summary>
    ''' Eigenschaft Gewicht. Setzt das Gewicht in Gramm oder gibt es in Gramm zurück.
    ''' </summary>
    ''' <returns>Gibt das Gewicht in Gramm zurück</returns>
    Public Property Weight As Integer
    ''' <summary>
    ''' Eigenschaft Groesse. Setzt die Größe in Zentimeter oder gibt es in Zentimeter zurück.
    ''' </summary>
    ''' <returns>Gibt die Größe in Zentimeter zurück</returns>
    Public Property Size As Integer

    ''' <summary>
    ''' Das Alter der Person
    ''' </summary>
    ''' <returns></returns>
    Public Property Age As Integer

End Class