visual basic 2008 voorbeelden en boeken / visual basic 2010 voorbeelden en boeken

Visual Basic is - net als de meeste andere object geörienteerde talen - een statisch getypeerde programmeertaal.

Dit houdt in dat elke expressie van een bepaald datatype is. Het datatype kan doorgaans worden afgeleid ( door de compiler ) op basis van de bijhorende declaratie of definitie.

Een expressie is een uitdrukking die een bepaalde "waarde" aanduidt. Dit kan in allerlei vormen zijn : literals, variabelen ( inclusief datavelden en argumenten ), voorwaarden ( booleaanse expressies ), rekenkundige bewerkingen, member-calls, object initializers, ...

Class Addition
    Public Sub New(ByVal term1 As Integer, ByVal term2 As Integer)
        Me.Term1 = term1
        Me.Term2 = term2
    End Sub
    Private m_Term1 As Integer
    Public Property Term1() As Integer
        Get
            Term1 = m_Term1
        End Get
        Set(ByVal value As Integer)
            m_Term1 = value
        End Set
    End Property
    Private m_Term2 As Integer
    Public Property Term2() As Integer
        Get
            Term2 = m_Term2
        End Get
        Set(ByVal value As Integer)
            m_Term2 = value
        End Set
    End Property
    Public Function GetSum() As Double
        GetSum = Term1 + Term2
    End Function
    Public Overrides Function ToString() As String
        ToString = Term1 & " + " & Term2 & " = " & GetSum()
    End Function
End Class
Class Example
    Public Shared Sub Main()
        Dim number As Integer
        number = 5                                             ' (1)
        Do While number < 10                                   ' (2)
            Console.WriteLine(number)                          ' (3)
            number = number + 1                                ' (4)
        Loop
        Dim addition1 As Addition = New Addition(3, number)    ' (5)
        Console.WriteLine("sum : " & addition1.GetSum())       ' (6)
        Console.WriteLine(addition1.Term2)                     ' (7)
        '
        Console.ReadLine()
    End Sub
End Class

Laten we even een aantal expressies bekijken uit bovenstaande client :

(1) : 5 : Integer literal : Integer expressie
(2) : number < 10 : voorwaarde : Boolean expressie
(3) : number : variabele : Integer expressie
(4) : number + 1 : rekenkundige bewerking : Integer expressie
(5) : New Addition(3, number) : object initializer : Addition expressie
(6) : "de som is : " : String literal : String expressie
(6) : addition1.GetSum() : member-call : Double expressie
(7) : addition1.Term2 : member-call : Integer expressie

Het datatype van een expressie wordt door de compiler herkend, en wordt ook wel het statisch type van een expressie genoemd ( hier afgekort tot STE ) gezien het statisch ( at compiletime ) is bepaald.

Een datatype bepaald :

- de range van mogelijke waarden : naar welke waarden kunnen expressies van dit type wijzen
- de opslagstructuur : hoe worden waarden van dit datatype in het geheugen bewaard
- de mogelijke bewerkingen/boodschappen die kunnen worden aangeroepen op expressies van dit type : welke members kunnen worden aangeroepen op een (object-)expressie van een bepaald STE

Vooral dit laatste is hier voor dit hoofdstuk van belang. Onthoud dus goed dat in een statisch getypeerde programmeertaal het STE bepaald welke members kunnen worden aangeroepen op een bepaalde objectexpressie ( met dat STE ).

Naast statisch getypeerde programmeertalen bestaan er ook dynamisch getypeerde programmeertalen ( ook wel ongetypeerde programmeertalen genoemd ). Daar wordt dus niet statisch ( at compiletime ), maar at runtime nagegaan of een ontvangerexpressie ( objectexpressie ) wel degelijk de boodschap verstaat die erop wordt aangeroepen.

Dit heeft als gevolg dat er at runtimefouten kunnen optreden ( dus tijdens uitvoering ) wanneer bijvoorbeeld die ontvangerexpressie de boodschap niet verstaat. Dit in tegenstelling tot statisch getypeerde programmeertalen waar reeds at compiletime ( dus nog voor het uitvoeren ) deze fout is opgetreden.

Runtimefouten leiden doorgaans tot programma-afbreking en zouden bijgevolg beter vermeden worden. Bij een compileerfout kan niet worden gebuild en kan er geen uitvoerbaar geheel gecreëerd worden, waarin er bijgevolg ook geen fouten ( veroorzaakt door bovenvermelde omstandigheid ) kunnen zitten.