29.11.2011, 09:37 PM
(1) Programmierung
(1.1) Geschichte
Die Befehle, die ein Prozessor ausführen kann (sein sog. Befehlssatz) werden seit jeher durch binäre Zahlen bestimmter Länge dargestellt. Auf einen Befehl folgen die zu verarbeitenden Daten, ebenfalls in binärer Form. Diese Nullen und Einsen in einer sinnvollen Wiese im Arbeitssprecher angelegt ergeben ein Programm.
In den Anfangstagen der Computergeschichte hat man nun diese Befehle mittels Lochstreifen, Steckverbindungen oder Kippschaltern dem Rechenwerk zugeführt. Ein entspreche langes Programm war allerdings nur sehr schwer zu verstehen und Entwicklung bzw. Fehlersuche besonders mühsam.
So begann man den einzelnen Befehlen Buchstabenkürzel zuzuordnen, die sog. Mnemonics. Die Buchstabenkürzel erinnerten an die Funktion des zugehörigen Befehls und erhöhten so die Lesbarkeit des Codes drastisch. Die Kürzel gefolgt von den Daten gab man nun in einen Texteditor ein, von dort wurden sie mit einem speziellen Programm, dem sog. assembler, wieder in Maschinensprache übersetzt. Die "Programmierumgebung" war geboren.
Aber auch diese Methode ist nicht besonders flexibel und umständlich. So begann man höhere Programmiersprachen zu entwickeln, die mit ihren syntaktischen (=Satzbau) und logischen (=z.B. Verzweigungen: WENN->DANN) Konstrukten stark der Menschlichen Sprache, bzw. Denkweise ähneln.
Der hochsprachliche Code wird nun von einem Compiler wieder in Maschinenbefehle übersetzt.
Wir arbeiten hier mit vb.net, einer Programmiersprache, die auf BASIC (Beginners All Purpose Symbolic Instruction Code) basiert. Sie ist besonders einfach zu verstehen, da sie der englischen Sprache auffallend nahe kommt. Auf die Bedeutung elementarer Codewörter wie z.B. "As" oder "New" werde ich daher nicht eingehen.
(1.2.1) Codewörter
Codewörter sind die "Anweisungen" der Programmiersprache. Sie "sagen" dem Compiler, was getan werden soll. Variablen oder Funktionen dürfen in ihrem Namen nicht mit vordefinierten Codewörtern übereinstimmen.
Biespiele
(1.2.2) Variablen, Konstanten und Operatoren
Dies sind die elementaren Werkzeuge innerhalb eines Programmcodes. Variablen & Konstanten können verschiedene Informationen tragen: Ganzzahlen, Kommazahlen, Text, "Wahr/Falsch"
Daher unterscheidet man verschiedene Variablentypen:
-Integer (Byte, Int16, Int32, Int64): Vorzeichenbehaftete Ganzzahlen
-String: Alphanumerische Zeichen
-Boolean: True oder False
-Single/Double/Float: Vorzeichenbehaftete Kommazahlen, bestehend aus Mantisse und Exponent
Eine Variable kann in ihrem Wert geändert werden, eine Konstante nicht. Beide müssen jedoch vor ihrer Verwendung definiert werden (d.h. im Speicher wird entsprechender Speicherplatz reserviert):
Alle Zeichen innerhalb einer Zeile, die nach einem einfachen Anführungszeichen kommen, werden vom Compiler als Kommentar betrachtet.
Variablen unterschiedlichen Datentyps können in der Regel nicht direkt ineinander überführt werden. Entsprechende Wertzuweisungen sind unzulässig. Es existierten aber Funktionen zur Konversion der Datentypen.
Operatoren dienen nun dazu Variablen miteinander zu "verrechnen". Im einfachsten Fall kann man zwei Zahlen addieren:
Wobei "+" hier den Operator darstellt.
ist eine Kurzschreibweise für:
(1.2.3)Arrays
Ein Array ist eine Ansammlung von Variablen eines Datentyps. Es hat eine fest definierte Länge.
(1.3) Strukturen
(1.3.1) Verzweigungen
Verzweigungen werden verwendet, um Entscheidungen zu treffen:
(1.3.2) Schleifen
Schleifen werden verwendet, um Anweisungen öfters als einmal auszuführen.
Diese Schleife wird durchlaufen, bis i den Wert 100 erreicht hat. Nach jedem Durchlauf wird i um den Wert 1 erhöht.
Diese Schleife wird solange ausgeführt, wie die Variable "myTester" den Wert True hat.
(1.4) Paradigmen
(1.4.1) Imperative Programmierung
Das Programm besteht nur aus hintereinander ausgeführten Befehlen. (Verzweigungen und Schleifen existieren). Soll ein Teil des Codes erneut ausgeführt werden, ist eine Sprunganweisung nötig, die die Ausführung des Programms an einer anderen Stelle fortsetzt. Selbiger Code ist extrem unleserlich und wird daher als "Spaghetti-Code" bezeichnet.
(1.4.2) Prozedurale Programmierung
Bei der prozeduralen Programmierung werden immer wieder benötigte Programmteile in Funktionen ausgelagert. Diesen Funktionen können, bzw. müssen Variablen übergeben werden, mit denen die Funktion intern arbeitet. Subroutinen ("Subs") können keine Werte zurückgeben, Funktionen ("Function") dagegen schon.
Die übergebenen Variablen, können entweder nach Wert "ByVal" oder nach Referenz "ByRef" übergeben werden. Im ersten Fall wird nur der explizite Wert an die Funktion übergeben, im Zweiten eine Zeiger auf die Variable, die so auch von der Funktion manipuliert werden kann.
(1.4.3) Objektorientierte Programmierung
Hier werden nicht nur Funktionen als wiederkehrende Elemente eingesetzt, sondern sog. Klassen. Eine Klasse besteht aus Variablen und Funktionen ? in diesem Kontext "Methoden" genannt.
Eine klasse kann beliebig oft instanziert werden. Die genauen Hintergründe würden hier den Rahmen leider sprengen, aber Wikipedia weiß Rat.
Wichtig ist, dass alle Methoden und Variablen, die eine Klasse beinhaltet entweder gekapselt "Private" oder öffentlich "Public" sein können. Erstere sind nur innerhalb der Klasse zugänglich, Letzere sind von außen sichtbar.
Wenn ich nun eine Klasse instanziert habe und auf öffentliche Methoden zugreifen will, benötige ich den Punkt-Operator (".").
Hier ein einfaches Beispiel, dass einen Auto-Tuner simuliert.
Wir arbeiten Objektorientiert.
(1.1) Geschichte
Die Befehle, die ein Prozessor ausführen kann (sein sog. Befehlssatz) werden seit jeher durch binäre Zahlen bestimmter Länge dargestellt. Auf einen Befehl folgen die zu verarbeitenden Daten, ebenfalls in binärer Form. Diese Nullen und Einsen in einer sinnvollen Wiese im Arbeitssprecher angelegt ergeben ein Programm.
In den Anfangstagen der Computergeschichte hat man nun diese Befehle mittels Lochstreifen, Steckverbindungen oder Kippschaltern dem Rechenwerk zugeführt. Ein entspreche langes Programm war allerdings nur sehr schwer zu verstehen und Entwicklung bzw. Fehlersuche besonders mühsam.
So begann man den einzelnen Befehlen Buchstabenkürzel zuzuordnen, die sog. Mnemonics. Die Buchstabenkürzel erinnerten an die Funktion des zugehörigen Befehls und erhöhten so die Lesbarkeit des Codes drastisch. Die Kürzel gefolgt von den Daten gab man nun in einen Texteditor ein, von dort wurden sie mit einem speziellen Programm, dem sog. assembler, wieder in Maschinensprache übersetzt. Die "Programmierumgebung" war geboren.
Aber auch diese Methode ist nicht besonders flexibel und umständlich. So begann man höhere Programmiersprachen zu entwickeln, die mit ihren syntaktischen (=Satzbau) und logischen (=z.B. Verzweigungen: WENN->DANN) Konstrukten stark der Menschlichen Sprache, bzw. Denkweise ähneln.
Der hochsprachliche Code wird nun von einem Compiler wieder in Maschinenbefehle übersetzt.
Wir arbeiten hier mit vb.net, einer Programmiersprache, die auf BASIC (Beginners All Purpose Symbolic Instruction Code) basiert. Sie ist besonders einfach zu verstehen, da sie der englischen Sprache auffallend nahe kommt. Auf die Bedeutung elementarer Codewörter wie z.B. "As" oder "New" werde ich daher nicht eingehen.
(1.2.1) Codewörter
Codewörter sind die "Anweisungen" der Programmiersprache. Sie "sagen" dem Compiler, was getan werden soll. Variablen oder Funktionen dürfen in ihrem Namen nicht mit vordefinierten Codewörtern übereinstimmen.
Biespiele
Code:
Dim
Private
Inherits
Function
(1.2.2) Variablen, Konstanten und Operatoren
Dies sind die elementaren Werkzeuge innerhalb eines Programmcodes. Variablen & Konstanten können verschiedene Informationen tragen: Ganzzahlen, Kommazahlen, Text, "Wahr/Falsch"
Daher unterscheidet man verschiedene Variablentypen:
-Integer (Byte, Int16, Int32, Int64): Vorzeichenbehaftete Ganzzahlen
-String: Alphanumerische Zeichen
-Boolean: True oder False
-Single/Double/Float: Vorzeichenbehaftete Kommazahlen, bestehend aus Mantisse und Exponent
Eine Variable kann in ihrem Wert geändert werden, eine Konstante nicht. Beide müssen jedoch vor ihrer Verwendung definiert werden (d.h. im Speicher wird entsprechender Speicherplatz reserviert):
Code:
Dim myVariable As Int32 'oder auch mit direkter Wertzuweisung:
Dim myVariable As Int32 = 12
Variablen unterschiedlichen Datentyps können in der Regel nicht direkt ineinander überführt werden. Entsprechende Wertzuweisungen sind unzulässig. Es existierten aber Funktionen zur Konversion der Datentypen.
Code:
Dim myStr As String
Dim myInt As Int32
Dim myDbl As Double = 2.5
'Falsch:
myInt = myDbl
myStr = myInt
'Richtig:
myInt = CInt(myDbl)
myStr = myInt.ToString()
Operatoren dienen nun dazu Variablen miteinander zu "verrechnen". Im einfachsten Fall kann man zwei Zahlen addieren:
Code:
Dim a, b, c As Int32
a = 5
b = 7
c = a + b 'Es folgt: c = 12
Code:
i *= 4
Code:
i = i * 4
(1.2.3)Arrays
Ein Array ist eine Ansammlung von Variablen eines Datentyps. Es hat eine fest definierte Länge.
Code:
Dim i(2) As Double 'Länge = 3
i(0) = 2.3
i(1) = 7.978
i(2) = i(0) / i(1)
(1.3) Strukturen
(1.3.1) Verzweigungen
Verzweigungen werden verwendet, um Entscheidungen zu treffen:
Code:
If schoenesWetter = True Then
MsgBox("lass uns rausgehen")
Else
MsgBox("Mist!")
End If
Code:
Select Case hausnummer
Case 666
MsgBox("The Number of the Beast")
Case 668
MsgBox("Der Nachbar vom Biest")
Case 667
MsgBox("Andere Straßenseite")
End Select
(1.3.2) Schleifen
Schleifen werden verwendet, um Anweisungen öfters als einmal auszuführen.
Code:
Dim i As Int
For i = 0 To 100
....
Next i
Code:
Do While myTester = True
...
Loop
(1.4) Paradigmen
(1.4.1) Imperative Programmierung
Das Programm besteht nur aus hintereinander ausgeführten Befehlen. (Verzweigungen und Schleifen existieren). Soll ein Teil des Codes erneut ausgeführt werden, ist eine Sprunganweisung nötig, die die Ausführung des Programms an einer anderen Stelle fortsetzt. Selbiger Code ist extrem unleserlich und wird daher als "Spaghetti-Code" bezeichnet.
(1.4.2) Prozedurale Programmierung
Bei der prozeduralen Programmierung werden immer wieder benötigte Programmteile in Funktionen ausgelagert. Diesen Funktionen können, bzw. müssen Variablen übergeben werden, mit denen die Funktion intern arbeitet. Subroutinen ("Subs") können keine Werte zurückgeben, Funktionen ("Function") dagegen schon.
Die übergebenen Variablen, können entweder nach Wert "ByVal" oder nach Referenz "ByRef" übergeben werden. Im ersten Fall wird nur der explizite Wert an die Funktion übergeben, im Zweiten eine Zeiger auf die Variable, die so auch von der Funktion manipuliert werden kann.
Code:
'Definitionen
Sub q_s(ByRef i As Int32)
i = i * i
End Sub
Function q_f(ByVal i As Int32) As Int32
Dim ergebnis As Int32
ergebnis = i * i
Return ergebnis
End Sub
'So werden die Funktionen aufgerufen:
Dim a As Int32 = 2
Dim b As Int32 = 2
q_s(a) '->a = 4
b = q_f(a) '->a = 4; b = 16
(1.4.3) Objektorientierte Programmierung
Hier werden nicht nur Funktionen als wiederkehrende Elemente eingesetzt, sondern sog. Klassen. Eine Klasse besteht aus Variablen und Funktionen ? in diesem Kontext "Methoden" genannt.
Eine klasse kann beliebig oft instanziert werden. Die genauen Hintergründe würden hier den Rahmen leider sprengen, aber Wikipedia weiß Rat.
Wichtig ist, dass alle Methoden und Variablen, die eine Klasse beinhaltet entweder gekapselt "Private" oder öffentlich "Public" sein können. Erstere sind nur innerhalb der Klasse zugänglich, Letzere sind von außen sichtbar.
Wenn ich nun eine Klasse instanziert habe und auf öffentliche Methoden zugreifen will, benötige ich den Punkt-Operator (".").
Hier ein einfaches Beispiel, dass einen Auto-Tuner simuliert.
Code:
'die Klasse:
Public Class auto
'Variablen
Private marke As String
Private motrorleistung As Int32
'Methoden
Public Sub setMarke(m As String)
marke = m
End Sub
Public Sub setLeistung(l As Int32)
motorleistung = l
End Sub
Public Function getMarke() As String
Return marke
End Function
Public Function getLeistung() As Int32
Return motorleistung
End Function
Public Sub leistungVerdoppeln()
leinstung *= 2
End Sub
End Class
'mein Programm
Dim astra As New auto 'der Tuner (=Instanz)
Dim eKlasse As New auto 'und sein Konkurrent (=Instanz)
astra.setLeistung(65)
astra.setMarke("Opel")
eKlasse.setLeistung(500)
eKlasse.setMarke("Daimler")
Do While astra.getLeistung() < eKlasse.getLesitung()
astra.leistungVerdoppeln() 'der Tuner schraubt am Auto rum
Loop
Wir arbeiten Objektorientiert.
Pffffffffft. "Da entwich das Vakuum" - Heinrich Physik, 1857.