Drucken
Hauptkategorie: Visual Basic

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.

 

Überladen

So kommen wir auch direkt zum nächsten Thema. Das sogenannte Überladen von Funktionen. In Visual Basic kann man "Sub" und "Function" überladen. Ein "Sub" und eine "Function" sind Funktionen, die sich nur darin unterscheiden, dass die "Sub" keine Werte zurück gibt. In anderen Sprachen wie Java steht statt "Sub" das Wörtchen "void". Mit Überladen meint man die mehrfache Erzeugung von Funktionen, die im Namen her gleich heißen, aber unterschiedliche Argumente enthalten.

Überladen wir den Konstruktor "new()". Unter den ersten Konstruktor schreiben wir den überladenen.

    ''' <summary>
    ''' Erzeugt eine Person mit den angegebenen Eigenschaften
    ''' </summary>
    ''' <param name="Age">Das Alter</param>
    ''' <param name="Size">Die Größe</param>
    ''' <param name="Weight">Das Gewicht</param>
    ''' <param name="Gender">Das Geschlecht</param>
    Public Sub New(Age As Integer, Size As Integer, Weight As Integer, Gender As Sexes)
        Me.Age = Age
        Me.Size = Size
        Me.Weight = Weight
        Me.Gender = Gender
    End Sub

Mit diesem Konstruktor können wir eine Person schneller erstellen. Im Konstruktor selbst weisen wir die Argumente direkt an die Eigenschaften weiter. Das Wörtchen "Me" zeigt dabei auf die in dieser Klasse globalen Eigenschaften, die wir im 1.Teil bereits erzeugt hatten. So können die Argumente genauso benannt werden, wie die Eigenschaften selbst. Unsere komplette Personenklasse sieht nun wie folgt aus.

''' <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>
    ''' Erzeugt eine Person als Objekt
    ''' </summary>
    Public Sub New()

    End Sub

    ''' <summary>
    ''' Erzeugt eine Person mit den angegebenen Eigenschaften
    ''' </summary>
    ''' <param name="Age">Das Alter in Jahren</param>
    ''' <param name="Size">Die Größe in Zentimeter</param>
    ''' <param name="Weight">Das Gewicht in Gramm</param>
    ''' <param name="Gender">Das Geschlecht</param>
    Public Sub New(Age As Integer, Size As Integer, Weight As Integer, Gender As Sexes)
        Me.Age = Age
        Me.Size = Size
        Me.Weight = Weight
        Me.Gender = Gender
    End Sub

    ''' <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

Von nun an, können wir eine Person mit einem Einzeiler schreiben oder die klasische Methode verwenden.

        'neue Methode
        Dim p As New Person(29, 170, 54000, Person.Sexes.Female)

        'klassische Methode
        Dim p1 As New Person()
        p1.Age = 29
        p1.Size = 170
        p1.Weight = 54000
        p1.Gender = Person.Sexes.Female

Welche Methode die elegantere ist, wird sich von Einsatzzweck zu Einsatzzweck unterscheiden. Manchmal benötigt man einfach nur ein instanziertes Objekt Person und füllt es später mit Werten, oder lässt es in einer anderen Funktion mit Werten füllen, oder auch nur aktualisieren. Von daher haben beide Konstruktoren ihre Berechtigung. Löscht man aber z.B. den Konstruktor "New()" jetzt heraus, so kann man die Person nicht mehr mit "Dim p as new Person" erstellen.

 

Es ist also wichtig, dass man bei Angabe von Konstruktoren seine Objekte soweit öffnet, dass auch andere Szenarien abgedeckt werden. Aber so ist es auch möglich, seine Objekte abzusichern, um nur bestimmte Möglichkeiten zu bieten. Im Vordergrund steht dabei immer das Ziel, welches das Objekt erfüllen soll.

Eine weitere Möglichkeit möchte ich euch auch noch zeigen. Das ist die Möglichkeit ein Objekt mit Hilfe eines Creaters zu erstellen. Nunja, das klingt erst einmal schlimmer als es das ist. Mit Sicherheit habt ihr bereits sogenannte "Shared" Funktionen gesehen. In anderen Sprachen werden diese meistens durch das Wort "static" gekennzeichnet. Das sind Funktionen, die ohne eine Initialisierung des Objekt direkt aufgerufen werden. Auch mit einer solchen Funktion können wir ein instanziertes Objekt erzeugen.

    ''' <summary>
    ''' Erzeugt eine neue Person mit den angegebenen Eigenschaften
    ''' </summary>
    ''' <param name="Age">Das Alter</param>
    ''' <param name="Size">Die Größe</param>
    ''' <param name="Weight">Das Gewicht</param>
    ''' <param name="Gender">Das Geschlecht</param>
    ''' <returns>Gibt eine Person mit den angegebenen Eigenschaften zurück</returns>
    Public Shared Function CreatePerson(Age As Integer, Size As Integer, Weight As Integer, Gender As Sexes) As Person
        Dim p As New Person
        p.Age = Age
        p.Size = Size
        p.Weight = Weight
        p.Gender = Gender
        Return p
    End Function

Dies erzeugt eine neue Person, die dann wie folgt erzeugt werden kann.

Dim p3 = Person.CreatePerson(29, 170, 54000, Person.Sexes.Female)

Natürlich darf man dies auch ausführlicher schreiben.

Dim p3 As Person = Person.CreatePerson(29, 170, 54000, Person.Sexes.Female)

Doch das Ergebnis ist das Selbe.

Beschäftigen wir uns aber vorerst mit der Creater Funktion. Ich habe diese über den klassischen Konstruktor "New()" erzeugt. Aber einfacher kann man dies dank unseren 2. Konstruktors haben.

    ''' <summary>
    ''' Erzeugt eine neue Person mit den angegebenen Eigenschaften
    ''' </summary>
    ''' <param name="Age">Das Alter in Jahren</param>
    ''' <param name="Size">Die Größe in Zentimeter</param>
    ''' <param name="Weight">Das Gewicht in Gramm</param>
    ''' <param name="Gender">Das Geschlecht</param>
    ''' <returns>Gibt eine Person mit den angegebenen Eigenschaften zurück</returns>
    Public Shared Function CreatePerson(Age As Integer, Size As Integer, Weight As Integer, Gender As Sexes) As Person
        Return New Person(29, 170, 54000, Person.Sexes.Female)
    End Function

Oft findet man verschiedene Lösungen für ein und dasselbe Problem. Richtig sind beide. Eleganter finde ich die 2. Lösung. Wenn man so seine Objekte erzeugen lässt, trifft man den Geschmack der meisten Entwickler. Wie man welches Problem löst, hat nicht jeder Entwickler gleich gelernt. Und so greifen viele auf unterschiedliche Methoden zurück, um ein Problem zu lösen. Der eine schreibt lieber die lange Version, der andere mag die Kurzversion und andere greifen lieber auf Creater Funktionen zurück. Und so wie wir hier das Problem angegangen sind, so haben wir diese 3 Möglichkeiten mit geringem Einsatz quasi erschlagen.

Es existiert noch eine weitere Möglichkeit der Erzeugung eines Objekts über die lange Version mit nur einem Einzeiler. Den möchte ich euch nicht vorenthalten. Diese sollte man wenigstens 1x gesehen haben, damit man es versteht. Visual Basic kennt das Wort "With". Damit lässt sich ein "Dim p as new Person" auch auf eine Zeile beschränken.

Dim p4 As New Person With {.Age = 29, .Size = 170, .Weight = 54000, .Gender = Person.Sexes.Female}

Auch so lässt sich eine Person erzeugen. Darin wird der Konstruktor "New()" verwendet und nachträglich werden alle Eigenschaften gesetzt. Ihr werdet alle diese Möglichkeiten in Visual Basic finden. Selbst in Microsoft scheint da nicht immer Einigkeit zu herrschen. Es gibt viele Objekte, die nur über Creater Funktionen erstellt werden können (Habe aber leider keine parat). Deshalb ist es wichtig all diese Möglichkeiten zu kennen.

In diesem Teil möchte ich es dabei belassen. Wir werden im nächsten Teil die versprochene Familie erzeugen. Dabei werden wir wieder die Vorteile der Vererbung kennenlernen. Lasst euch überraschen...

So weit...