Wer ist online?
Buchempfehlung
FreeBASIC-Chat
FreeBASIC-Nachrichten jetzt auch über Twitter erhalten. Follow us!Tutorial
Warum OOP?
von  ytwinky | Seite 3 von 5 |
SCOPE löst dieses Problem. Nur bestimmte Prozeduren können bestimmte Dinge ändern und so ist klar, welche Prozeduren darauf geprüft werden müssen, ob sie etwas verändert haben könnten und die meisten sind es nicht gewesen, da ja nur einige dafür in Frage kommen. Aber, was ist, wenn jetzt Prozeduren Parameter verändern müssen? Dann können die Parameter byREF übergeben werden und damit steht schon mal fest WO es passiert sein könnte. Dies Verfahren ist natürlich nicht immer sicher und so können wir auch hier in Schwierigkeiten geraten. Also UDT! Das löst das Problem von zuvielen Parametern und da sie als Parameter an die Proceduren übergeben werden, gibt es das Problem der globalen Variablen nicht. Alles ist in seinem eigenen Bereich und es gibt eine Sache weniger, um die man sich kümmern muß. Unglücklicherweise müssen die UDTs aber byREF übergeben werden, wenn die Prozeduren die Variablen des UDTs verändern sollen. Aber dann könnten dieselben Probleme auftreten, wie bei globalen Variablen, da ja, wenn UDTs byREF an jede Prozedur übergeben werden, 20 Prozeduren darauf warten, Variablen zu verändern und möglicherweise auch durcheinanderzubringen. Also was? Wir brauchen mehr SCOPE-Regeln!
Darum geht es aber bei Verkapselung. Variablen kommen in einen UDT, aber einige von ihnen werden PRIVATE gemacht. Was ist'n das nu' wieder? Das bedeutet, niemand sonst kann auf diese Variablen zugreifen! Sie sind innerhalb des UDT versteckt, sodass eine Prozedur diese Varaiablen nicht verändern kann, wenn ich den UDT an sie übergebe. Tatsächlich kann nicht einmal die Prozedur(oder das Hauptprogramm), das den UDT erstellt, die Variablen verändern:
Type meinUDT
Public:
As Integer erlaubt
Private:
As Integer verboten
End Type
Dim etwas As meinUDT
'Das ist OK
etwas.erlaubt = 3
Print etwas.erlaubt
'Das ist NICHT OK
etwas.verboten = 5
Print etwas.verbotenDas wirft natürlich die Frage auf, wer denn nun wirklich diese Variablen verändern KANN? Denn, wenn keiner überhaupt diese Variablen ändern kann, was soll das dann? Bei einem Sprite könnten x und y versteckt sein, damit keiner das Sprite nach Belieben herumbewegen kann. Aber wenn KEINER auf die (x, y)-Variablen zugreifen kann, wie kann es dann überhaupt bewegt werden? Und woher sollten wir wissen, WO es zu zeichnen wäre?
Darum haben wir etwas zu den UDTs hinzugefügt: die sogenannten 'methods'(Methoden). Jetzt geht's los mit OOP. Es mag zunächst ein wenig befremdlich klingen, aber es löst wirklich eine Menge Probleme. Jetzt kann nur noch EINE Prozedur die Position des Sprites verändern und falls ein Fehler auftritt, ist klar, wo das geschehen sein muß!
Type meinSprite
Public:
Declare Sub Move (neu_x As Integer, neu_y As Integer)
Declare Sub Draw ()
Private:
As Integer x, y
End Type
Sub meinSprite.Move (neu_x As Integer, neu_y As Integer)
x = neu_x
y = neu_y
End Sub
Sub meinSprite.Draw ()
Pset (x, y), &hffffff
End SubNun könnten wir es einfach auch so schreiben:
Type meinSprite
As Integer x, y
End Type
Sub MoveSprite (tsprite As meinSprite, neu_x As Integer, neu_y As Integer
tsprite.x = neu_x
tsprite.y = neu_y
End Sub
Sub DrawSprite (tsprite As meinSprite)
Pset (tsprite.x, tsprite.y), &hffffff
End SubAber dann ginge die Verkapselung verloren und es gäbe wieder die SCOPE-Probleme, weil jeder dann auf x und y zugreifen kann. Dies Beispiel zeigt noch etwas anderes auf, was wir untersuchen müssen: Stil
Es könnte der Eindruck entstehen, das wäre unerheblich, aber das stimmt nicht. Z.B. obwohl Einrückungen nicht wirklich die Programmausführung beeinflussen, ist das Programm wesentlich leichter zu lesen
If etwas = 1 Then
Do
Print "Hi"
Loop While etwas = 1
End Ifals
If etwas = 1 Then
Do
Print "Hi"
Loop While etwas = 1
End IfUnd es gibt andere Bereiche, auf die das zutrifft.
Gehe zu Seite | Zusätzliche Informationen und Funktionen | |||||||
|---|---|---|---|---|---|---|---|
|
|||||||
Bearbeiten
Versionen