Einfuehrung in das Programmieren mit Visual BasicI

HTL Wien 22 - Abteilung für Elektrotechnik
Programmieren mit Visual Basic
Einführung in das Programmieren mit
Visual Basic
Erstellt am 18.1.2001 von Lothar Kerbl
Letzte Änderung: 18.1.2001
L.Kerbl : Einführung in VB
19.01.01
Seite 1 von 19
HTL Wien 22 - Abteilung für Elektrotechnik
Programmieren mit Visual Basic
Inhaltsverzeichnis:
Einleitung ................................................................................................................................................................ 3
Aufruf von VB, Ausführen eines Programmes........................................................................................................ 4
Übersicht über den Befehlsumfang von VB ............................................................................................................ 9
Kontrollstrukturen: .............................................................................................................................................. 9
VB als blockstrukturierte Sprache ..................................................................................................................... 10
Arten von Variablen .......................................................................................................................................... 11
Ausschnitt aus der VB-Dokumentation ................................................................................................................. 12
Übergeben von Argumenten an Prozeduren...................................................................................................... 12
Datentypen von Argumenten......................................................................................................................... 12
Übergeben von Argumenten als Wert ........................................................................................................... 12
Übergeben von Argumenten als Referenz ..................................................................................................... 12
Verwenden optionaler Argumente................................................................................................................. 13
Definieren eines Standardwerts für ein optionales Argument ....................................................................... 13
Verwenden einer unbestimmten Anzahl an Argumenten .............................................................................. 14
Erstellen einfacherer Anweisungen mit benannten Argumenten................................................................... 14
Unterstützung von benannten Argumenten ................................................................................................... 14
Gültigkeitsbereich von Variablen ...................................................................................................................... 15
Definieren des Gültigkeitsbereichs von Variablen ........................................................................................ 15
Variablen innerhalb einer Prozedur ............................................................................................................... 15
Variablen auf Modulebene ............................................................................................................................ 15
Variablen für alle Module.............................................................................................................................. 15
Ausgabefenster ...................................................................................................................................................... 16
Eingabefenster, ereignisgesteuertes Programmieren ............................................................................................. 17
Ereignissteuerung, von Anfang an........................................................................................................................ 18
L.Kerbl : Einführung in VB
19.01.01
Seite 2 von 19
HTL Wien 22 - Abteilung für Elektrotechnik
Programmieren mit Visual Basic
Einleitung
Für eine Anwendung von VB sprechen:
•
•
•
•
•
•
•
•
•
Möglichkeit zur blockorientierten und objektorientierten Programmierung gleichzeitig
Einfache und gleichzeitig umfassendere Syntax als C (z.B.: Schleife)
Geringer "Strukturelementeoverhead" (keine öffnenden Klammern, als "schließende Klammer" wird
der Befehlsname wiederholt)
Umfassende Möglichkeiten der Datenübergabe an Unterprogramme
Ersatz der Makrosprache für Applikationen EXCEL, WORD, ACCESS,...
Nutzung von Windows Resourcen (ActiveX)
Weitreichende Debug Möglichkeiten (Überwachung, Lokalfenster, Direktfenster,..)
Mit wenig Aufwand sind Ergebnisse mit "Windows-Look" erzielbar
Erlernen von C ist mit VB- Kenntnis leicht möglich
Nachteile von VB
o
o
o
VB ist eine zeilenorientierte Sprache
Einige Befehle sind nicht konsistent definiert (z.B.: Aufruf von Unterprogrammen mit und ohne
"CALL", "get" und "let" Funktionen,....)
Formulierungen bei objektorientierter Programmierung ist teilweise gewöhnungsbedürftig
Dieses Skriptum ist als Hilfe für den Umstieg von der "programmflussorientierten" auf die "objektorientierte"
Sicht des Programmierens konzipiert.
Zuerst wird die Erstellung eines "klassischen" (blockorientierten) Programmes in der Programmiersprache VB
erläutert.
Die Syntax der Sprache VB wird - soweit sie das "klassische" Konzept des blockorientierten Programmierstils
betrifft - dargestellt
Die Probleme, die sich bereits bei sehr einfachen Programmen bei der Datenausgabe und vor allem bei der
Dateneingabe ergeben, führen zum Konzept des ereignisgesteuerten Programmierens.
Ereignisgesteuertes Programmieren bedingt ein Abgehen vom programmflussorientierten Entwurf.
Als Alternative wird eine Einführung in den objektorientierten Entwurf dargestellt.
Auf weitergehende Konzepte des objektorientierten Ansatzes (Definition von Klassen, Vererbung) wurde nicht
eingegangen.
Ebenso wurde auf die Besonderheiten der Syntax für die Anwendung des objektorientierten Konzeptes nicht
näher eingegangen. Dabei wird auf die Dokumentation von VB verwiesen.
Für ausführliche Erläuterungen zum objektorientierten Programmierstil sei vor allem auf das Buch
"Objektorientierte Softwareentwicklung" von Bertrand Meyer (Deutsch: Hanser ISBN 3.446-15773-5)
verwiesen.
L.Kerbl : Einführung in VB
19.01.01
Seite 3 von 19
HTL Wien 22 - Abteilung für Elektrotechnik
Programmieren mit Visual Basic
Aufruf von VB, Ausführen eines Programmes
Ziel:
Ein lauffähiges "klassisches" Programm (auschließlich blockorientierter Programmtext eines Hauptprogrammes)
soll erstellt werden.
Das Programm soll im Einzelschrittmodus ("Debug") abgearbeitet werden, dabei wird die Zuweisung an
Variable wird überwacht
o
Aufruf von Visual Basic
o
Es wird das ausgewählte Standardprojekt angezeigt.
Falls dies nicht der Fall ist, wird ein neues "Standard EXE - Projekt" erstellt (Datei / Neues Projekt)
o
Ansicht/Projekt-Explorer öffnet ein Fenster mit einer Übersicht aller zum Projekt gehörenden Dateien
o
In der Standardvorgabe umfasst ein Projekt nur ein Formular (Form) Für unsere ersten
Programmierversuche im "klassischen prozedurorientierten" Stil benötigen wir kein Formular, deshalb
entfernen wir das Form1.......
L.Kerbl : Einführung in VB
19.01.01
Seite 4 von 19
HTL Wien 22 - Abteilung für Elektrotechnik
o
Programmieren mit Visual Basic
....und fügen stattdessen ein Modul hinzu
L.Kerbl : Einführung in VB
19.01.01
Seite 5 von 19
HTL Wien 22 - Abteilung für Elektrotechnik
Programmieren mit Visual Basic
o
In das Fenster von Modul1 schreiben wir den Programmcode
o
Bevor wir das Programm testen, öffnen wir das Direktfenster und das Überwachungsfenster
im Direktfenster können Ein- und Ausgaben während des Programmablaufes erfolgen ("Konsole")
Im Überwachungsfenster werden Inhalte von Variablen bzw. Werte von Ausdrücken angezeigt.
Auch die Anzeige des Lokalfensters leistet bei der Überwachung von Variablen praktische Dienste
L.Kerbl : Einführung in VB
19.01.01
Seite 6 von 19
HTL Wien 22 - Abteilung für Elektrotechnik
o
Programmieren mit Visual Basic
Nun können wir das Programm im Einzelschrittmodus ("Debuggen" - F8) durcharbeiten. Der nächste
auszuführende Befehl ist dabei immer mit einem gelben Balken unterlegt, im Überwachungsfenster
erscheinen die Inhalte der definierten Variablen.
Besonderheiten:
o
Im Einzelschrittmodus können im Direktfenster jederzeit Anweisungen (in VB-Syntax) eingegeben
werden, die unmittelbar ausgeführt werden. Z.B. kann im Direktfenster mit der Eingabe "a = 9" der
Wert von a auf 9 gesetzt werden.
o
Im Lokalfenster werden immer alle im aktuellen Kontext definierten Variablen angezeigt. Ist man nur
an dieser Darstellung interssiert (und nicht an der Auswertung von Ausdrücken) so ist diese Anzeige
"bequemer" als die Anzeige im Überwachungsfenster, da man sich die Definition der anzuzeigenden
Ausdrücke erspart.
o
Anzeigen im Direktfenster werden mit dem Befehl "debug.print" ausgegeben. (Näheres zum Operator
"." bei der Einführung in das objektorientierte Programmieren)
L.Kerbl : Einführung in VB
19.01.01
Seite 7 von 19
HTL Wien 22 - Abteilung für Elektrotechnik
Programmieren mit Visual Basic
Beenden
o
Abspeichern des Programmes erfolgt durch Datei /Speichern unter... bzw. durch Datei /Speichern.
Natürlich kann nur auf einen Bereich abgespeichert werden, für den die entsprechende
Zugriffsberechtigung besteht
o
Aus dem Projekt kann auch ein lauffähiges EXE-Programm erstellt und abgespeichert werden.
L.Kerbl : Einführung in VB
19.01.01
Seite 8 von 19
HTL Wien 22 - Abteilung für Elektrotechnik
Programmieren mit Visual Basic
Übersicht über den Befehlsumfang von VB
VB unterstützt durch die Syntax sowohl objektorientierte als auch blockorientierte Programmierung. Im
vorliegenden wird nur die Syntax dargestellt, soweit sie für die blockorientierte Programmierung von Bedeutung
ist.
Kontrollstrukturen:
Sequenz
Anweisungen, die zu einem Block zusammengefasst werden, sind durch ":" zu trennen und in "einer Zeile" zu
schreiben.
Zeilen können an beliebiger Stelle umgebrochen werden, sie müssen allerdings am Ende durch das
"Unterstreichungszeichen "_" auf eine Fortsetzung in der nächsten Zeile hinweisen.
Einstellige Verzweigung:
If <Bedingung> then <Anweisung>
Verzweigung mit Alternativanweisung:
If <Bedingung> then <Anweisung1> Else <Anweisung2>
Blockform der Verzweigung
If <Bedingung> then
<Anweisung1>
ElseIf <Bedingung>
<Anweisung2>
ElseIf <Bedingung>
<Anweisung3>
.......
Else
<Anweisungn>
End If
Select Case-Anweisung
Select Case <Testausdruck>
Case <Ausdrucksliste1>
<Anweisungen1>
Case <Ausdrucksliste2>
<Anweisungen2>
Case Else
<Anweisungen_n>
End Select
Kopfgesteuerte Schleife mit Fortsetzungsbedingung
Do while <Bedingung>
<Anweisung>
Loop
Kopfgesteuerte Schleife mit Abbruchbedingung
Do until <Bedingung>
<Anweisung>
Loop
Fußgesteuerte Schleife mit Fortsetzungsbedingung
Do
L.Kerbl : Einführung in VB
19.01.01
Seite 9 von 19
HTL Wien 22 - Abteilung für Elektrotechnik
Programmieren mit Visual Basic
<Anweisung>
Loop while <Bedingung>
Fußesteuerte Schleife mit Abbruchbedingung
Do
<Anweisung>
Loop until <Bedingung>
Zählschleife
For <Zähler> = <Anfang> to <Ende> Step <Schrittweite>
<Anweisung>
Next
"Für-alle-Elemente-Schleife"
For Each <Element> in <Gruppe>
<Anweisung>
Next
N+1/2 Schleife
Jede Schleife kann im Rumpf durch "Exit" vorzeitig (nach einem nicht vollendeteten Durchlauf des
Schleifenrumpfes) beendet werden
Sonderfälle:
Die "with" Anweisung ist eine verkürzte Schreibweise; man kann damit einen "Vorspann" vor einer Variablen
einmal angeben und erspart sich innehalb des durch "with"... "end with" geschachtelten Blockes die Angabe
dieses "Vorspannes".
Diese Schreibweise ist vor allem bei der Referenzierung von Objekteigenschaften von Bedeutung
Eine "Verzweigung" kann innerhalb einer Anweisung ausgeführt werden (vergleiche bedingte Formel in
EXCEL)
IIf(<Bedingung>,<TrueAusdruck>,<FalseAusdruck>)
VB als blockstrukturierte Sprache
Dim GlobalVar as Integer
Sub Main()
Dim A as Integer
A=5
ABC (A)
A=C+3
CDE (A)
A=C+3
A= FGH(A)
GlobalVar = 4
End Sub
auf Modulebene vereinb. Variable (ist für alle Elemente im Modul sichtbar)
' Sub... Definition einer Prozedur .. Main()=Hauptprogramm
'lokale Variable für das Hauptprogramm
Sub ABC (ByRef Zahl As Integer)
Dim C
C = 3+Zahl
Zahl =C
GlobalVar = 90
End Sub
L.Kerbl : Einführung in VB
'Übergabevariable sind REFERENZPARAMETER (!)-DEFAULT
'lokale Variable für das Unterprogramm (Verschattungsprinzip)
19.01.01
Seite 10 von 19
HTL Wien 22 - Abteilung für Elektrotechnik
Programmieren mit Visual Basic
Sub CDE (ByVal Zahl As Integer )
'Übergabevariable werden "ByVal" zu WERTEPARAMETERN
Dim C
Static K
'Variable lebt solange wie eine globale Variable, ist aber nur innerhalb von CDE "sichtbar"
C=3+Zahl
Zahl = C
End Sub
Function FGH (ByVal Zahl As Integer) As Integer
'Vereinbarung einer Funktion
FGH = Zahl*Zahl
'Rückgabewert über den Funktionsnamen
End Function
Neben FUNCTION und SUB gibt es PROPERTY - Routinen (-> Objektorientierte Programmierung)
Prozeduren und Variable können folgende "Eigenschaften der Sichtbarkeit" haben ( vorangestellte Bezeichnung)
PRIVATE (default)
Prozedur ist innerhalb des Moduls verfügbar
Variable ist innerhalb des Moduls zugreifbar, wenn sie auf Modulebene definiert ist
Variable ist innerhalb der Prozedur zugereifbar, wenn sie auf Prozedurebene definiert ist
PUBLIC
Prozedur (Variable) ist auch von außerhalb des Moduls zugreifbar
Hinweis:
Die Übergabeparameter in der Kopfzeile eines Unterprogrammes sind standardmäßig Referenzparameter (!);
Wert- und Referenzparameter werden durch die vorangestellten Schlüsselworte "ByVal" und "ByRef"
unterschieden.
Der Aufruf von SUB-Prozeduren erfolgt
Call <procedurname> (<Parameter1>, <Parameter2>)
Oder durch
<Procedurname> <Parameter1>, <Parameter2>
Beachte, dass im zweiten Fall KEINE Klammern verwendet werden.
Außerdem können in VB die Reihenfolge und die verwendeten Argumente frei gewählt werden (optionale
Argumente)
Arten von Variablen
DIM
"Standard"vereinbarung im Deklarationsteil des Moduls oder der Prozedur; Lebensdauer und Sichtbarkeit der
Variablen entsprechen den umschließenden Block
Variablen auf Modulebene sind grundsätzlich statisch; Variablen im Kontext einer Prozedur sind dynamisch
("Stackvariable")
L.Kerbl : Einführung in VB
19.01.01
Seite 11 von 19
HTL Wien 22 - Abteilung für Elektrotechnik
Programmieren mit Visual Basic
STATIC
Variablen im Deklarationsteil einer Funktion "überleben" den aktuellen Prozeduraufruf; sie sind allerdings nur
innerhalb des Blockes des Prozedur "sichtbar"; Das Schlüsselwort STATIC kann auch vor der Definition der
Prozedur stehen, in diesem Fall sind alle lokalen Variablen der Prozedur "statisch" (d.h. sie überleben einen
Aufruf der Prozedur)
Ausschnitt aus der VB-Dokumentation
Übergeben von Argumenten an Prozeduren
Der Code in einer Prozedur benötigt in der Regel einige Informationen über den Zustand des Programms, damit
er richtig ausgeführt werden kann. Diese Informationen werden der Prozedur beim Aufruf als Argumente
übergeben.
Datentypen von Argumenten
Die Argumente der von Ihnen geschriebenen Prozeduren haben als Voreinstellung den Datentyp Variant. Sie
können jedoch auch andere Datentypen für Argumente deklarieren. Der folgenden Funktion können z.B. eine
Zeichenfolge und eine Ganzzahl (Datentypen String und Integer) übergeben werden:
Function Mittagsmenü(Wochentag As String, Stunde As Integer) As String
' Gibt anhand von Tag und Uhrzeit ein Mittagsmenü zurück.
If Wochentag = "Freitag" then
Mittagsmenü = "Fisch"
Else
Mittagsmenü = "Huhn"
End If
If Stunde > 4 Then Mittagsmenü = "Zu spät"
End Function
Weitere Informationen Weitere Informationen zu Datentypen in Visual Basic finden Sie weiter oben in diesem
Kapitel. Auch im Sprachverzeichnis sind Einzelheiten zu bestimmten Datentypen enthalten.
Übergeben von Argumenten als Wert
Wird eine Variable als Wert übergeben, so wird nur eine Kopie der Variablen übergeben. Wenn die Prozedur
den Wert ändert, betrifft die Änderung nur die Kopie, aber nicht die Variable selbst. Mit dem Schlüsselwort
ByVal können Sie festlegen, daß eine Variable als Wert übergeben wird.
Beispiel:
Sub PostAccounts(ByVal intAcctNum as Integer)
.
. ' Anweisungen ...
.
End Sub
Übergeben von Argumenten als Referenz
Durch Übergabe von Argumenten als Referenz erhält die Prozedur Zugriff auf den aktuellen Inhalt der Variablen
an ihrer Adresse im Hauptspeicher. Der Wert der Variablen kann also von der Prozedur, der sie übergeben wird,
dauerhaft geändert werden. Die Übergabe von Argumenten als Referenz ist die Voreinstellung in Visual Basic.
Wenn Sie einen Datentyp für ein als Referenz übergebenes Argument angeben, müssen Sie für das Argument
einen Wert dieses Datentyps übergeben. Sie können dies umgehen, indem Sie anstelle eines Datentyps einen
Ausdruck für ein Argument übergeben. Visual Basic wertet einen Ausdruck aus und übergibt ihn nach
Möglichkeit mit dem erforderlichen Datentyp.
Sie können eine Variable am einfachsten in einen Ausdruck umwandeln, indem Sie sie in Klammern
einschließen. Um z.B. eine als Integer deklarierte Variable an eine Prozedur zu übergeben, die eine Zeichenfolge
als Argument erwartet, müßten Sie folgenden Code schreiben:
Sub AufrufendeProzedur()
Dim intX As Integer
L.Kerbl : Einführung in VB
19.01.01
Seite 12 von 19
HTL Wien 22 - Abteilung für Elektrotechnik
Programmieren mit Visual Basic
intX = 12 * 3
AufgerufeneProzedur(intX)
End Sub
Sub AufgerufeneProzedur(Bar As String)
MsgBox Bar
'Der Wert von Bar ist die Zeichenfolge "36".
End Sub
Verwenden optionaler Argumente
Sie können angeben, daß die Argumente einer Prozedur optional sind, indem Sie das Schlüsselwort Optional in
die Argumentliste aufnehmen. Wenn Sie ein optionales Argument angeben, müssen alle darauffolgenden
Argumente in der Argumentliste ebenfalls optional sein und mit dem Schlüsselwort Optional deklariert werden.
In den beiden folgenden Code-Stücken wird vorausgesetzt, daß ein Formular mit einer Befehlsschaltfläche und
einem Listenfeld existiert.
Der folgende Code stellt z.B. alle Argumente optional zur Verfügung:
Dim strName As String
Dim strAddress As String
Sub ListText(Optional x As String, Optional y AsString)
List1.AddItem x
List1.AddItem y
End Sub
Private Sub Command1_Click()
strName = "Ihr Name"
strAddress = 12345
' Beide Argumente übergeben.
Call ListText(strName, strAddress)
End Sub
Der folgende Code stellt dagegen nicht nur optionale Argumente zur Verfügung:
Dim strName As String
Dim varAddress As Variant
Sub ListText(x As String, Optional y As Variant)
List1.AddItem x
If Not IsMissing(y) Then
List1.AddItem y
End If
End Sub
Private Sub Command1_Click()
strName = "Ihr Name"
' Zweites Argument nicht
' übergeben.
Call ListText(strName)
End Sub
Wenn ein optionales Argument fehlt, wird dem fehlenden Argument der Datentyp Variant mit dem Wert
Empty zugewiesen. Das obige Beispiel verdeutlicht, wie man mit Hilfe der IsMissing-Funktion testen kann, ob
optionale Argumente fehlen.
Definieren eines Standardwerts für ein optionales Argument
Es ist auch möglich, einen Standardwert für ein optionales Argument zu definieren. Im folgenden Beispiel wird
ein Standardwert zurückgegeben, wenn das optionale Argument nicht an die Function-Prozedur übergeben wird:
Sub ListText(x As String, Optional y As Integer = 12345)
List1.AddItem x
List1.AddItem y
End Sub
Private Sub Command1_Click()
strName = "Ihr Name"
' übergeben.
Call ListText(strName)
' hinzufügen.
L.Kerbl : Einführung in VB
' Zweites Argument nicht
' "Ihr Name" und "12345"
19.01.01
Seite 13 von 19
HTL Wien 22 - Abteilung für Elektrotechnik
Programmieren mit Visual Basic
End Sub
Verwenden einer unbestimmten Anzahl an Argumenten
Im allgemeinen muß die Anzahl der Argumente in einem Prozeduraufruf mit der Anzahl der Argumente in der
Prozedurspezifikation übereinstimmen. Mit dem Schlüsselwort ParamArray können Sie festlegen, daß eine
Prozedur eine beliebige Anzahl von Argumenten akzeptieren soll. Dadurch wird das Schreiben von Funktionen
wie der folgenden Sum-Funktion ermöglicht:
Dim x As Integer
Dim y As Integer
Dim intSum As Integer
Sub Sum(ParamArray intNums())
For Each x In intNums
y = y + x
Next x
intSum = y
End Sub
Private Sub Command1_Click()
Sum 1, 3, 5, 7, 8
List1.AddItem intSum
End Sub
Erstellen einfacherer Anweisungen mit benannten Argumenten
In Visual Basic haben Sie bei vielen integrierten Funktionen, Anweisungen und Methoden die Möglichkeit, als
Vereinfachung benannte Argumente zu verwenden, um sich die Eingabe von mehreren Argumentwerten zu
ersparen. Mit Hilfe von benannten Argumenten können Sie ein beliebiges Argument oder alle Argumente in
beliebiger Reihenfolge angeben, indem Sie dem benannten Argument einen Wert zuweisen. Geben Sie dazu den
Argumentnamen und anschließend einen Doppelpunkt, ein Gleichheitszeichen und den Wert ein (Argument:=
"EinWert"), und fügen Sie diese Zuweisung in eine Folge von Argumenten ein, in der die Argumente durch
Kommas voneinander getrennt sind. Die Argumente im folgenden Beispiel sind im Vergleich zur eigentlichen
Syntax in umgekehrter Reihenfolge angegeben:
Function ListText(strName As String, OptionalstrAddress As String)
List1.AddItem strName
List2.AddItem strAddress
End Sub
Private Sub Command1_Click()
ListText strAddress:=„12345„, strName:="Ihr Name"
End Sub
Dies erweist sich als besonders hilfreich, wenn Ihre Prozeduren mehrere optionale Argumente enthalten, die Sie
nicht immer angeben müssen.
Unterstützung von benannten Argumenten
Die Automatische QuickInfo im Code-Editor-Fenster, der Objektkatalog oder die Informationen im
Sprachverzeichnis geben Ihnen Auskunft darüber, welche Funktionen, Anweisungen und Methoden benannte
Argumente unterstützen. Bei der Arbeit mit benannten Argumenten sollten Sie folgendes beachten:
• Methoden auf Objekten in der Visual Basic-Objektbibliothek (VB) unterstützen benannte Argumente
nicht. Unterstützung bieten jedoch alle Schlüsselwörter in der Objektbibliothek von Visual Basic für
Applikationen (VBA) sowie Methoden in der Bibliothek für Datenzugriffsobjekte (DAO).
•
In der angegebenen Syntax sind benannte Argumente fett und kursiv formatiert. Alle anderen
Argumente werden nur kursiv dargestellt.
Wichtig Sie können benannte Argumente nicht verwenden, um sich die Eingabe von erforderlichen Argumenten
zu ersparen. Es ist nur zulässig, optionale Argumente wegzulassen. Bei den Objektbibliotheken von Visual Basic
(VB) und Visual Basic für Applikationen (VBA) sind optionale Argumente im Objektkatalog in eckigen
Klammern [ ] eingeschlossen.
Weitere Informationen Weitere Informationen hierzu finden Sie unter „ByVal“, „ByRef“, „Optional“ und
„ParamArray“ im Sprachverzeichnis.
L.Kerbl : Einführung in VB
19.01.01
Seite 14 von 19
HTL Wien 22 - Abteilung für Elektrotechnik
Programmieren mit Visual Basic
Gültigkeitsbereich von Variablen
Durch den Gültigkeitsbereich einer Variablen wird definiert, welche Teile Ihres Codes von ihrer Existenz
„wissen“. Wenn Sie eine Variable innerhalb einer Prozedur deklarieren, kann nur Code innerhalb dieser
Prozedur auf diese Variable zugreifen oder ihren Wert ändern; ihr Gültigkeitsbereich ist also nur auf die
Prozedur beschränkt (man bezeichnet sie deshalb auch als lokale Variable). Manchmal ist es jedoch notwendig,
Variablen mit einem größeren Gültigkeitsbereich zu verwenden, z.B. solche, die für alle Prozeduren in einem
Modul oder sogar in der gesamten Anwendung verfügbar sind. In Visual Basic können Sie bei der Deklaration
einer Variablen auch ihren Gültigkeitsbereich definieren.
Definieren des Gültigkeitsbereichs von Variablen
Je nach der Deklaration einer Variablen ist sie entweder auf die lokale Prozedurebene oder auf die Modulebene
beschränkt.
Gültigkeitsbereich
Privat
Öffentlich
Innerhalb einer Prozedur können Sie
Die Variablen sind auf die Prozedur,
Prozedurebene
keine öffentlichen Variablen
in der sie enthalten sind, beschränkt.
deklarieren.
Die Variablen sind auf das Modul, in Die Variablen sind in allen Modulen
Modulebene
dem sie enthalten sind, beschränkt.
verfügbar.
Variablen innerhalb einer Prozedur
Variablen auf Prozedurebene werden nur in der Prozedur erkannt, in der sie deklariert wurden. Sie werden daher
auch als lokale Variablen bezeichnet. Sie können die Variablen deklarieren, indem Sie die Schlüsselwörter Dim
oder Static verwenden. Beispiel:
Dim intTemp As Integer
–Oder–
Static intPermanent As Integer
Lokale Variablen, die mit Static deklariert sind, bleiben während der gesamten Laufzeit Ihrer Anwendung
bestehen. Lokale Variablen, die mit Dim deklariert sind, bleiben dagegen nur bestehen, bis die Prozedur beendet
ist
Lokale Variablen bieten sich für alle Arten von Zwischenrechnungen an. Sie können z.B. mehrere Prozeduren
erstellen, die die Variable intTemp enthalten. Solange jede Variable mit dem Namen intTemp als lokale
Variable deklariert ist, erkennt jede Prozedur nur ihre eigene Version von intTemp. Jede einzelne Prozedur
kann den Wert ihrer lokalen Variablen intTemp ändern, ohne daß die Variablen intTemp in anderen
Prozeduren davon beeinflußt werden.
Variablen auf Modulebene
Standardmäßig stehen alle Variablen auf Modulebene in allen Prozeduren des Moduls, in dem sie enthalten sind,
zur Verfügung, aber nicht im Code anderer Module. Sie können Variablen auf Modulebene erstellen, indem Sie
sie im Deklarationsabschnitt am Anfang des Moduls mit Public oder Private deklarieren. Beispiel:
Private intTemp As Integer
Auf Modulebene besteht kein Unterschied zwischen Private und Dim, aber es ist ratsam, das Schlüsselwort
Private zu verwenden, da es sich deutlicher von Public abgrenzt und der Code so lesbarer wird.
Variablen für alle Module
Um eine Variable auf Modulebene anderen Modulen zur Verfügung zu stellen, müssen Sie die Variable mit dem
Schlüsselwort Public deklarieren. Die Werte in öffentlichen Variablen sind für alle Prozeduren in Ihrer
Anwendung verfügbar. Wie alle Variablen auf Modulebene müssen auch öffentliche Variablen im
Deklarationsabschnitt am Anfang des Moduls deklariert werden. Beispiel:
Public intTemp As Integer
Anmerkung Innerhalb einer Prozedur können Sie keine öffentlichen Variablen deklarieren. Das ist nur im
Deklarationsabschnitt eines Moduls möglich.
Weitere Informationen Weitere Informationen zu Variablen finden Sie unter „Weiterführende Informationen
zu Variablen“ (nur in der Online-Dokumentation).
L.Kerbl : Einführung in VB
19.01.01
Seite 15 von 19
HTL Wien 22 - Abteilung für Elektrotechnik
Programmieren mit Visual Basic
Ausgabefenster
Die Ausgabe eines Programmes soll nicht auf einen Text im Direktfenster beschränkt bleiben.
Um die Ausgabe "an Windows angepasst" zu gestalten, müssen wir ein "FORM-Objekt" zu unserem Projekt
hinzufügen.
Dazu benutzen wir wieder den Explorer und fügen das Fenster, das wir für unser einführendes Programm
entfernt haben, wieder hinzu. (Kontextmenü auf "Projekt1" / Hinzufügen / Formular)
•
Wir können - entweder mit dem grafischen Editor oder mit einem Eintrag in der Eigenschaftsliste - die
Eigenschaften des Fensters "Form1" ändern
•
Wir können ein Textfeld in das leere Fenster einfügen. Damit "enthält" unser Fensterobjekt ein
Textfeldobjekt
Sowohl die Eigenschaften des Fensterobjektes als auch die des im Fensterobjekt enthaltenen Anzeigeobjektes
(Textfeld) können verändert werden:
•
•
durch Ändern in der Eigenschaftsliste (dabei werden die "Initialwerte" festgelegt)
durch den Programmcode (damit können die Werte der Eigenschaften während des Programmablaufes
geändert werden)
Natürlich können im Programmcode auch mehrere Anzeigeobjekte im Ausgabefenster verwaltet werden oder
mehrere Ausgabefenster geöffnet und geschlossen werden.
"Gebrauch" eines Objektes bedeutet:
•
•
Ändern der Eigenschaftswerte
Aufrufen der "Methoden" des Objekts
Wichtig:
L.Kerbl : Einführung in VB
19.01.01
Seite 16 von 19
HTL Wien 22 - Abteilung für Elektrotechnik
•
•
Programmieren mit Visual Basic
Die Eigenschaften eines Objektes können generell durch Auswahl des Punktes "Eigenschaften" im
Kontextmenü editiert werden
Sobald ein Fenster in der Projektzusammenstellung definiert ist, wird automatisch beim Starten des
Programmes nur das Fenster aktiviert (als Ausgangspunkt eines ereignisgesteuerten Programmes). Um
den Code auszuführen, muss die Eigenschaft "Startobjekt" des Projekts (Kontextmenü für "Projekt1" im
Projektexplorer) auf Sub Main gesetzt werden.
Eingabefenster, ereignisgesteuertes Programmieren
In der Behandlung der Eingabeschnittstelle eines Programmes hat sich mit der Entwicklung der Fenstertechnik
ein entscheidender Wandel vollzogen. "Benutzerfreundlich" bedeutet:
•
•
•
der Benutzer soll die momentan "aktuellen" Objekte des Programmes nach seinem Ermessen nutzen
können.
Nicht aktuelle Objekte des Programmes sollen vor dem Benutzer verborgen bleiben
Nicht erlaubte Nutzung muss unterbunden werden.
Die konsequente Umsetzung des ersten Punktes führt zu unhandlichen "klassischen" Programmstrukturen.
Dies war einer der Gründe, warum der Weg des "klassischen blockorientierten prozeduralen Programmierens"
verlassen wurde und das Konzept des "ereignisgesteuerten Programmierens auf Objekten" entwickelt wurde.
Grundlage:
•
Die Objekte kommunizieren untereinander durch Botschaften, wobei in dieser Botschaft der Name des
Objekts und die Botschaft
(z.B.: Form1.Show Form1 ... Name des Objekts, Show ... Botschaft, was zu tun ist)
•
Der Benutzer selbst ist in diese Kommunikation eingebunden, er kann mit den sichtbaren Objekten
durch Tastatureingabe oder Mausaktionen kommunizieren
•
Jedes Objekt stellt für das Auftreten der Ereignisse Routinen (Methoden) zur Verfügung. Diese
Methoden werden ausgeführt, sobald das Ereignis auftritt. (z.B.: Form1 stellt - wie jedes andere Fenster
- eine Methode "Show" zur Verfügung, die grundsätzlich von "jedermann" aufgerufen werden kann.)
•
Ein Objekt hat einen Namen
•
Ein Objekt ist durch bestimmte Attribute gekennzeichnet. Die Zusammenfassung dieser Attribute
betsimmen die Klasse des Objekts
•
Ein Objekt kann erzeugt werden, dabei müssen die Klasse des Objekts und eine
"Objektreferenzvariable" angegeben werden
•
Ein Objekt kann Verweise auf andere Objekte beinhalten
Konsequenz:
Objektorientierte Programme sind in ihren Kontrollstrukturen meist einfacher als prozedurorientierte Programme
Objektorientierte Programme bauen auf der Verwendung von Zeigern auf
L.Kerbl : Einführung in VB
19.01.01
Seite 17 von 19
HTL Wien 22 - Abteilung für Elektrotechnik
Programmieren mit Visual Basic
Ereignissteuerung, von Anfang an
Konsequenterweise bleibt als einzige Aktivität des Hauptprogrammes, das erste benötigten Fenster zu öffnen
Auch diese Aktivität muss im Rahmen eines VB- Programmes nicht mehr durch Programmcode ausgeführt
werden. Man mussnur die Eigenschaften des Startobjektes ändern werden ("Projekt"/"Eigenschaften"/
"Startobjekt": Form1 anstelle von Sub Main())
Ist das erste Fenster geöffnet, wird die weitere "Ereigniskette" normalerweise durch eine Aktion des Benutzers
gestartet.
Ereignisroutinen (Methoden) für ein Objekt können angezeigt werden (Objekt anklicken / "Code anzeigen"..)
Eigenschaften (Attribute) eines Objektes können angezeigt werden (Objekt anklicken / "Eigenschaften"..)
Methoden:
"OnClick"
"OnChange"
"......"
Attribute:
"Caption"
.....
Durch Drücken eines Knopfes (Aktivieren der Methode "OnClick" des Objektes "Eingabeknopf0" wird das
Attribut "Text" des betätigten Eingabeknopfes auf den Wert "Ich wurde gedrückt" gesetzt
Durch Drücken eines Knopfes (Aktivieren der Methode "OnClick" des Objektes "Eingabeknopf1" wird das
Attribut "Text" des "Ausgabefeldes" auf den Wert "Eingabe wurde gedrückt" gesetzt
In der Ereignisprozedur wird ein Attribut des eigenen oder eines anderen Objektes geändert
In einer Ereignisprozedur kann ein weiteres Ereignis (mehrere weitere Ereignisse) ausgelöst werden. Diese
Prozedur wird "durch Verwenden einer Methode" des Zielobjektes initiiert (Angabe durch Punktschreibweise)
Durch Drücken eines Knopfes (Aktivieren der Methode "OnClick" des Objektes "Eingabeknopf2" wird die
Methode "Verstecken" des betätigten Eingabeknopfes angewählt.
Durch Drücken eines Knopfes (Aktivieren der Methode "OnClick" des Objektes "Eingabeknopf3" wird zweimal
hintereinander die Methode "Öffnen" des Fensters "Unterfenster" angewählt.
Ein Ereignis löst eine Ereignisprozedur des eigenen oder eines anderen Objektes aus !
Das Eingabefenster soll durch eine selbst geschriebene Ereignisprozedur und durch ein selbst definiertes Attribut
erweitert werden. Das Ereignisprozedur wird
Durch Drücken eines Knopfes (Aktivieren der Methode "OnClick" des Objektes "Eingabeknopf2" erscheint am
Knopf der Text "ich wurde bereits x mal gedrückt" (Anzahl der Drückvorgänge wird als Attribut für diesen
Knopf definiert !)
L.Kerbl : Einführung in VB
19.01.01
Seite 18 von 19
HTL Wien 22 - Abteilung für Elektrotechnik
Programmieren mit Visual Basic
Durch Drücken eines Knopfes (Aktivieren der selbstdefinierten Methode "Multipliziere" des Objektes
"Ausgabefenster" wird der Wert von zwei Eingabefeldern miteinander multipliziert und in diesem
Ausgabefenster dargestellt..
Zusätzliche Ereignisprozeduren und Attribute können für jedes Objekt selbst definiert werden
Ein Objekt "Rechner" wird definiert; seine Attribute sollen Eingabe1, Eingabe2 und Ergebnis sein (keine
Fenster)
Außerdem sind die für diesen Rechner definierten Methoden :
Werte_einlesen, Addieren, subtrahieren, Multiplizieren, Ergebnis_ausgeben
Anschließend soll dieser Rechner durch Tasten gesteuert werden
Selbstverständlich können diese Ereignisse auch von beliebigen anderen Quellen initiert werden, und
selbstverständlich kann jedes Programm (jedes andere Objekt), das "das Objekt Rechner kennt" es für seine
Zwecke benutzen
Objekte können über auschließlich selbst definierte Eigenschaften und Methoden definiert werden.
Objekte können als Attribute Verweise auf andere Objekte enthalten
OOP besteht im Anlegen einer Sammlung "geeigneter" Objekte.
Die "Ausführung" besteht in der Nutzung der Attribute und Methoden dieser Objekte durch den Anwender (oder
ein anderes Programm)
Diese Vorgaben bedingen einen grundsätzlich anderen Prozess des Softwareentwurfes (höheres
Abstraktionsniveau als beim prozedurorientierten Entwurf)
L.Kerbl : Einführung in VB
19.01.01
Seite 19 von 19