BlitzMax: OOP (alt)

Zurück zur Übersicht

Was ist OOP?

OOP steht für Objekt Orientierte Programmierung.

BlitzMax ist ein Basic-Dialekt, der objektorientiert ist. Man kann eigene Klassen erstellen, diese von anderen Klassen ableiten, den Aufruf des Konstruktors nutzen (zum Teil), Methoden deklarieren und vieles mehr.

Objekte kannst du dir als Variablen vorstellen, nur dass du viel mehr mit ihnen anfangen kannst. In BMax sind sie fast genau wie Types, nur mit dem Unterschied, dass du Methoden definieren kannst. Methoden sind nichts weiter als Funktionen innerhalb dieses Types. Diese gelten auch jeweils für eine Instanz dieses Types. Diese speziellen Types nennt man Klassen, Instanzen dieser nennt man Objekte.

---

Type TVektor
 
 Field x:Double, y:Double, z:Double
 
End Type

Dieses Beispiel erstellt eine Klasse TVektor mit dem Schüsselwort Type. C++-Programmierer könnten sich das ungefähr so vorstellen:

class TVektor
{
 public:
  double x;
  double y;
  double z;
}

Grundlagen

Methoden

Eine Klasse kann auch Funktionen haben, die beim Aufruf ausgeführt werden. Diese nennt man Methoden und sie werden mit dem Keyword (Schlüsselwort) Method deklariert.

'Klasse Punkt
Type TPunkt
 
 Field x,y
 
 Method Zeichnen()
  Plot x,y
 End Method
 
End Type

Basisklassen (Vererbung)

In BlitzMax (kurz: BMax) ist es im Gegensatz zu anderen Basic-Dialekten möglich, eigene Basisklassen zu erstellen. Dass eine Klasse zu einer Basisklasse gehört, wird durch das Schlüsselwort extends markiert.

Beispiel:

'Basisklasse
Type TGrafikObjekt
 
 Field x,y
 
End Type

'Abgeleitete Klasse
Type TKreis extends TGrafikObjekt
 
 Field radius
 
End Type

Abstrakte Methoden

Möchte man in einer davon abgeleiteten Klasse dieselbe Funktion nutzen, fügt man zusätzlich noch das Keyword abstract hinzu, welches verdeutlicht, dass es eine Vorlage für eine Funktion ist:

'Basisklasse
Type TGrafikObjekt
 
 Field x,y
 
 Method Zeichnen() abstract
 
End Type

'Abgeleitete Klasse
Type TKreis extends TGrafikObjekt
 
 Field radius
 
 Method Zeichnen()
  DrawOval x-radius,y-radius,radius*2,radius*2
 End Method
 
End Type

Dies ist allerdings kein Muss, denn eine Methode kann auch ohne das Schlüsselwort abstract in einer davon abgeleiteten Klasse überschrieben werden. Das abstract bedeutet nur, dass für diese Methode noch keine Implementation vorliegt. Damit wird auch die ganze Klasse abstract, was somit auch zur Folge hat, dass man keine Instanzen (Objekte dieser Klasse) dieser Basisklasse erzeugen kann. Folglich muss eine abgeleitete Klasse alle Methoden der Basisklasse überschreiben, da sie sonst nicht definiert wären.

'Basisklasse
Type TPunkt
 
 Field x,y
 
 Method Zeichnen() abstract
  Plot x,y
 End Method
 
End Type

'Abgeleitete Klasse
Type TKreis extends TPunkt
 
 Field radius
 
 Method Zeichnen()
  DrawOval x-radius, y-radius, radius*2, radius*2
 End Method
 
End Type

Self

Bei anderen Programmiersprachen heißt dieses Keyword this. In Blitz Max nennt man es Self. Mit Self kann eine Klasse sich selbst ansprechen und eigene Werte verändern. Self drückt sehr viel deutlicher aus, welche Daten gemeint sind und sollte möglichst oft verwendet werden. Es wird - wenn nötig - implizit vom Compiler eingefügt.

'Basisklasse
Type TGrafikObjekt
 
 Field x,y
 
 Method Zeichnen()
  Plot Self.x, Self.y
 End Method
 
End Type

'Abgeleitete Klasse
Type TKreis extends TGrafikObjekt
 
 Field radius
 
 Method Zeichnen()
  DrawOval Self.x-radius, Self.y-radius, Self.radius*2, Self.radius*2
 End Method
 
End Type

Erweitert

Vererbung

Siehe Basisklassen

Polymorphie

Man unterscheidet statische und dynamische Polymorphie. Wenn eine Programmiersprache statische Polymorphie beherrscht, kann man mehrere Funktionen mit demselben Namen und unterschiedlichen Parametern erstellen, welche zum geeigneten Zeitpunkt aufgerufen werden. Beispiel in C:

int test(int a)
{
 return a;
}

float test(float a)
{
 return a;
}

int test(int a, int b)
{
 return a + b;
}

Statische Polymorphie ist in Blitz Max nicht möglich. Dynamische Polymorphie ist hingegen möglich.

SuperStrict

'die abstrakte Klasse 
'dient zur Interface Definition
Type AbstractExampleClass
	Method DoSomething() Abstract 
End Type

'Die erste Klasse, die was machen soll
Type ExampleOne Extends AbstractExampleClass

	Function Create:ExampleOne ()
		Local example : ExampleOne = New ExampleOne
		Return example	
	End Function
	
	Method DoSomething()
		Print "Hello"
	End Method
End Type

'Die zweite Klasse, die was machen soll
Type ExampleTwo Extends AbstractExampleClass

	Function Create:ExampleTwo ()
		Local example : ExampleTwo = New ExampleTwo 
		Return example	
	End Function
	
	Method DoSomething()
		Print "World !"
	End Method
End Type

'Ich stecke beide Klassen in einen Array der vom abstrakten Typ ist
Local myExampleArray : AbstractExampleClass[2]

myExampleArray[0] = ExampleOne.Create()
myExampleArray[1] = ExampleTwo.Create()

'Jetzt zeigt sich die Polymorphie
myExampleArray[0].DoSomething()
myExampleArray[1].DoSomething()

Standardwerte für Funktionsparameter

Mit diesem Feature ist es möglich, den letzten Parametern Standardwerte zuzuweisen, die dann automatisch gesetzt werden, wenn der Aufruf der Funktion diese Parameter nicht enthält. Dies ersetzt keinesfalls die Polymorphie, da die Parameter der Funktion weiterhin gleich bleiben (durch abstrakte bzw. virtuelle Klassen kann man polymorphe Funktionen bzw. Methoden zumindest teilweise ersetzen). In der Praxis sieht das folgendermaßen aus:

Function Error(code:int,msg:string="",source:string="unknown")
    Print "Es ist ein Fehler aufgetreten. Code: "+code+"("+source+") "+msg
EndFunction

' Hier wird als msg automatisch ein leerer String gesetzt
' und als source "unknown" angeben
Error(1) 

' Hier wird nur source automatisch vergeben, da msg angegeben ist
Error(1, "Konnte Datei xy nicht öffnen")

' Hier ist nur code und source angegeben, msg wird quasi "übersprungen"
Error(1,,"System")

' Hier sind alle Parameter angegeben
Error(1, "Konnte Datei xy nicht öffnen","System")