Vererbung

[Lewi]

Hallo Manfred,
warum beim 1. Mal INITCLASS() 2x aufgerufen wird und beim 2.Mal nur einmal ist mir auch nicht ganz klar. ZUmindest ist aus der Doku nichts zu entnehmen.

Ich habe mal folgende Vermutung:

Die Methode INITCLASS der Superklasse wird immer 2x aufgerufen, wenn sie einer Unterklasse ihre Eigenschaften vereerbt und die Unterklasse selbst noch nicht instanziert wurde. Mag sein, dass dies in Zusammenhang mit der in xbase++ möglichen Mehrfachvererbung zusammen hängt.

[Manfred]

Hallo Olaf,

dann ist jetzt der Punkt, an dem ich nochmals sagen muß: "Ich habe nichts, oder alles falsch verstanden". Ich war bisher der Meinung (so habe ich es aus den Erklärungen bisher gelesen, die hier stehen) dass die initclass nur 1x aufgerufen wird und zwar bei der 1. Bildung eines Objektes und dann nicht wieder. Die bei dem Vorgang initialisierten Var aber dann jedem weiteren gebildeten Objekt zur Verfügung stehen. Ob meine Annahme jetzt Sinn ergibt oder nicht, so habe ich es aber verstanden. Und deshalb bin ich etwas verwirrt, weil ich kann ansonsten die Sache mit der initclass immer noch nicht so ganz verstehen, zu welchem Sinn und Zweck die da sein soll, wenn die doch immer wieder aufgerufen wird.

Bis hierhin erstmal, vielleicht kommt ja jetzt langsam Licht ins Dunkel?

[Robert]

Hallo,

also ich seh das so:

Die Klasse Test ist von der Klasse Datenbank abgeleitet. Also wird zuerst die initClass und anschließend die init-Methode der Klasse Datenbank aufgerufen.
Anschließend wird dann initClass und init für die Klasse test aufgerufen. initClass deshalb, da sie ja von der Klasse Datenbank vererbt wurde. Da sie nicht neu implementiert wurde, wird die Funktionialität aus Datenbank:initClass ausgeführt.

Wenn du jetzt die Klasse test2 instanzierst wird deshalb nur einmal initClass aufgerufen, da die Methode initClass der Klasse Datenbank ja bereits einmal ausgeführt wurde (selbe Klasse). Test2 ist aber eine andere Klasse als test und Datenbank, daher wird jetzt nur die initClass Methode der Klasse test2 aufgerufen.

Also nochmal kurz:
oTest := test():new() -> Datenbank:initClass()
-> Datenbank:init()
-> test:initClass()
-> test:init()

oTest2 := test2():new() -> (Datenbank:initClass nicht, da bereits geschehen)
-> Datenbank:init()
-> test2:initClass()
-> test:init()

So würde es in meinen Augen Sinn ergeben. Wenn das falsch ist, bitte korrigieren

[Manfred]

Die Klasse Test ist von der Klasse Datenbank abgeleitet. Also wird zuerst die initClass und anschließend die init-Methode der Klasse Datenbank aufgerufen.

Das ist klar, so habe ich es auch verstanden...

Anschließend wird dann initClass und init für die Klasse test aufgerufen. initClass deshalb, da sie ja von der Klasse Datenbank vererbt wurde. Da sie nicht neu implementiert wurde, wird die Funktionialität aus Datenbank:initClass ausgeführt.

Wenn du jetzt die Klasse test2 instanzierst wird deshalb nur einmal initClass aufgerufen, da die Methode initClass der Klasse Datenbank ja bereits einmal ausgeführt wurde (selbe Klasse). Test2 ist aber eine andere Klasse als test und Datenbank, daher wird jetzt nur die initClass Methode der Klasse test2 aufgerufen.

Also nochmal kurz:
oTest := test():new() -> Datenbank:initClass()
-> Datenbank:init()
-> test:initClass()
-> test:init()

oTest2 := test2():new() -> (Datenbank:initClass nicht, da bereits geschehen)
-> Datenbank:init()
-> test2:initClass()
-> test:init()

So würde es in meinen Augen Sinn ergeben. Wenn das falsch ist, bitte korrigieren

Da liegt ja meine Frage drin, warum überhaupt so einen Weg wählen?
Ich habe den Sinn und Zweck der initClass nach meinem Versuch nicht mehr verstanden.

Eigentlich wollte ich folgendes Szenario einfacher haben, bzw. war der Meinung das ich es zu kompliziert gebaut habe:

Code: Alles auswählen

Class datenbank
         PROTECTED:
         VAR cVerzeichnis

         EXPORTED:
         VAR id,;
                cDbank,;
                cSuffix

         METHOD init
Endclass
**************************************
METHOD datenbank:init
                        ::id := 0
                        ::cSuffix := ".dbf"
RETURN self
**************************************
**************************************
CLASS test FROM datenbank
           EXPORTED:
           VAR name

           METHOD initvaria
ENDCLASS
**************************************
METHOD test:initvaria
             ::cDbank := "test"
RETURN self
**************************************
**************************************
CLASS test2 FROM datenbank
           EXPORTED:
           VAR name

           METHOD initvaria
ENDCLASS
**************************************
METHOD test2:initvaria
             ::cDbank := "test"
RETURN self
**************************************
**************************************
PROCEDURE main()
oTest := test():new():initvaria()
oTest2 := test2():new():initvaria()
return 

Mit oben genanntem Code habe ich erreicht, dass die init Methode von der Superklasse aufgerufen wird und die initvaria Methode von der erbenden Klasse. Anders ging es nicht, wie ich es ausprobiert hatte.

Bis hierhin erstmal und dann weitersehen.....

[Robert]

Jetzt ist die Frage was du damit denn eigentlich machen willst.

Die Klassen test und test2 sind ja erstmal völlig identisch. Da könntest du ja auch der Methode init einen Parameter <cDbName> übergeben um dann z.B. so einen Aufruf zu gestalten:

Code: Alles auswählen

oTest  := test():new("test")    
oTest2 := test():new("andererTest")

In deinem deiner Meinung nach komplizierterem Szenario hätte jedes Objekt was du erzeugst, seine eigene id und seinen eigenen suffix.

oTest:cSuffix := ".dat"

könnte dann Dateien mit andere Endung öffnen als oTest2 (welches dann ja noch .dbf hätte.

In dem Beispiel davor hätten alle Objekte der Klasste test dieselbe Id und den selben Suffix und auch alle Objekte der Klasse test2 (wenn ich da jetzt nichts durcheinander bringe)

Hättest du also bei dem Beispiel mit den Klassenvariablen folgende Objekte erzeugt:

Code: Alles auswählen

oTest   := test():new()  
oTest2 := test():new
oTest3 := test2():new()  
oTest4 := test2():new()  

Würde ein Aufruf von

Code: Alles auswählen

oTest:cSuffix := ".dat"
oTest3:cSuffix := ".txt"

bewirken, dass oTest und oTest2 Dateien mit der Endung .dat assozieren und die die Objekte oTest3 und oTest4 mit .txt

[Manfred]

Nee, ja, hm, grrr,

das waren 2 Beispiele. Ich wollte nicht soviel TExt schreiben. Mir ging es in 1.Linie darum kurz zu zeigen was ich will.

Es gibt eine Superklasse, in der die allgemeinen Var sind.

Dann gibt es pro Datenbank eine erbende Klasse, in denen der Pfad, der Dateiname, das Indexarray usw. in var geschrieben wird. Praktisch genau so, wie man es in der OOP versteht. Alle erben erstmal das was alle gleich haben und der Rest wird dann unterschiedlich zugeordnet.

test war das eine DB-Objekt und
test2 war das nächste usw. usw. usw.

Jetzt weiß ich wieder, dass die init Methode (konstruktor) der Superklasse entweder bei der Erzeugung der Instanz aufgerufen wird, oder wenn diese Methode in der Superklasse nicht vorhanden ist, bzw. in der Instanz, dann wird die init Methode der Instanz aufgerufen. Gut, bis hier hin paßt es.

So, Das hatte ich Anfangs ein wenig vergessen und mich gewundert, warum die Superklasse ihre Methode nicht immer aufruft. Weiß ich jetzt aber wieder, kann abgehakt werden.

Ich muß aber nun die Superklassen Vars auch irgendwie initialisieren. Hm, also kam ich dann irgendwie auf die Idee es über die Instanz zu machen, aber nicht mit init, sondern mit initvaria. Dadurch wurde die Superklassen init aufgerufen und die (init) der Instanz.

Ich wollte nur wissen, ob es auch einfacher geht, oder ob ich halt jedesmal

otest := test():new():initvaria() aufrufen muß

also habe ich gesucht und dachte ich hätte mit initclass etwas anderes einfacheres gefunden, weil ja die Superklassenvaria jedesmal neu inititalisiert werden. Ich hatte es so verstanden, dass sie jetzt nur noch einmal und zwar bei der 1. Instanzbildung gesetzt werden und dann nicht mehr wieder, sondern direkt jeder weiteren Instanz zur Verfügung stehe.

Also: Habe ich hier wohl was in den falschen Hals gekriegt (komisch, habe doch nur einen )

[Robert]

Ich wollte nur wissen, ob es auch einfacher geht, oder ob ich halt jedesmal

otest := test():new():initvaria() aufrufen muß

Wenn ich dich richtig verstanden habe suchst du sowas:

Code: Alles auswählen

Class datenbank 
         PROTECTED: 
         VAR cVerzeichnis 

         EXPORTED: 
         VAR id,; 
                cDbank,; 
                cSuffix 

         METHOD init 
Endclass 
************************************** 
METHOD datenbank:init 
                        ::id := 0 
                        ::cSuffix := ".dbf" 
RETURN self 
************************************** 
************************************** 
CLASS test FROM datenbank 
           EXPORTED: 
           VAR name 

           METHOD init
ENDCLASS 
************************************** 
METHOD test:init()
             ::datenbank:init() // init der Superklasse aufrufen
            // test:init() - spezifische Initialisierungen 
             ::cDbank := "test" 
RETURN self 
************************************** 

************************************** 
PROCEDURE main() 
oTest := test():new()
return

 

[Manfred]

Hi Robert,

wo liegt denn da der Unterschied?

Ob ich jetzt in der init der Instanz, oder direkt hinter der Bildung es aufrufe?

[Robert]

wo liegt denn da der Unterschied?

Der einzige Unterschied ist jetzt wirklich nur das fehlen der Methode initvaria, da alle Variablen, die die Klasse benötigt nun in der init-Methode inititialisiert werden.

Es bleibt nun dir Überlassen, wie du das aufbaust. Ich find es so übersichtlicher, da alle Variableninitialisierungen an einer Stelle stattfinden.

Da du nach einem einfachereren Aufruf als otest := test():new():initvaria() gesucht hast, dachte ich du meinst sowas.

[Manfred]

ich hatte das so schon einmal versucht,

da ich aber zu blöde war zu wissen, das man

::datenbank:init()

so aufruft, hat das auch nicht geklappt. Das habe ich aber auch erst vorhin genau gesehen, als ich die Antwort schon abgeschickt hatte.

Also, es war auf jeden Fall ein guter Tipp drin....

Danke.

[Manfred]

Jetzt bin ich aber immer noch nicht schlauer, was initclass betrifft.

[olaf870]

Hallo Jungs,

große Verwirrung hier im Forum.

Die Methode INITCLASS wird genau NUR einmal aufgerufen, das aber bei Instanzierung jeder Klasse, die von der Klasse, die die Methode INITCLASS enthält, abgeleitet ist.

Sind also die Klassen ClassA und ClassB von ClassMain abgeleitet, und INITCLASS eine Methode von ClassMain, so wird INITCLASS aufgerufen wenn

1 eine Instanz der ClassA erzeugt wird
2 eine Instanz der ClassB erzeugt wird und
3 eine Instanz der ClassMain erzeugt wird

Eine Instanz der ClassMain wird implizit erzeugt, sobald man eine davon abgeleitete Klasse instanziiert.

Auch ist es nicht so, daß INIT-Methoden der Superklassen bei Instanzierung einer abgeleiteten Klasse automatisch aufgerufen werden. Stets müssen bei Xbase in der INIT-Methode alle INIT-Methoden von allen Superklassen explizit gerufen werden.
Z. B.:

Code: Alles auswählen

CLASS DlgGet FROM _DlgGet, dataDialog, 
METHOD DlgGet:init( oP )
         ::_DlgGet:init( oP )
         ::dataDialog:init( oP )
RETURN self

Von der Logik her ist verständlich, denn die INIT-Methoden der Superklassen brauchen ja meist auch ein paar Parameter und irgendwie müssen die ja übergeben werden.

Der Autor der Xbase-Doku setzt m.E. einfach zuviel voraus. Wie unser Tutor im ersten Uni-Semester mir versicherte, der Mathe-Prof mache eine Super-Vorlesung für ihn (als Doktoranten der Mathematik), ist es auch mit der Doku: man versteht die Ausführungen zur OOP dort erst dann, wenn man sich das Know-How woanders besorgt hat. So ging es mir jedenfalls. Früher konnte ich ist damit nicht viel anzufangen. Heute finde sie trotz rekordverdächtiger Knappheit ziemlich vollständig.
Den Sinn von INITCLASS und das Verhalten von Class-Variablen versteht man intuitiv, wenn man das leicht abgewandelte Beispiel von Manfred ansieht:

Code: Alles auswählen

#include "Xbp.ch"
#include "Appevent.ch"
#include "inkey.ch"

PROCEDURE Main
    oDb := datenbank():new()
    oDbTest := test():new()
 
    oDb:id := "von oDb gesetzt"
    oDbTest:id := "von oDbTest gesetzt"

    oDbTest2 := test():new()
    ? oDbTest2:id

    oDb2 := datenbank():new()
    ? oDb2:id
    inkey(0)
RETURN

Class datenbank
         PROTECTED:
         CLASS VAR cVerzeichnis

         EXPORTED:
         CLASS VAR id

         CLASS METHOD initClass
Endclass

**************************************
CLASS METHOD datenbank:initClass
                        ::id := 0
RETURN self

**************************************
CLASS test FROM datenbank
           EXPORTED:
           VAR name

           METHOD init
ENDCLASS
**************************************
METHOD test:init
             ::cDbank := "test"
RETURN self
**************************************
**************************************

Man sieht hier, daß die ClassVar ::iD hat verschiedene Werte hat, je nachdem von welcher Klasse man draufguckt und das ist gut so.

Gruß
Olaf870

[Manfred]

Hi Olaf,

ich behaupte einmal den Unterschied zwischen init und initclass, den weiß ich jetzt.....

Das war auch eigentlich die ursprüngliche Frage. Da hätte ich auch schon früher drauf kommen können, wenn ich nur die Augen aufgemacht hätte. Aber ich schätze einmal, dass ich mich so in dieses Thema verrannt hatte, dass ich vor lauter Wald keine Bäume mehr gesehen habe.

Diese Methode initClass macht genau das, wonach ich gefragt habe:

Sie wird IMMER automatisch ausgeführt bei der Instanzbildung einer Klasse. Nur, und jetzt kommt der Unterschied, im Gegensatz zur einfachen init Methode einer Superklasse wird sie auch automatisch ausgeführt, wenn es in der Instanz eine init Methode gibt. Und das ist der Unterschied zur einfachen init Methode einer Superklasse. Die wird nämlich nur dann ausgeführt, wenn es KEINE init Methode in der Instanz gibt. Wenn es eine init Methode einer Instanz gibt und die Superklassen init Methode auch ausgeführt werden soll/muß, dann muß sie extra aufgerufen werden, oder aber eine init Methode in der Instanz mit einem anderen Namen benannt und die aufgerufen werden.

oTest := test():new():initvaria() --> wenn es nur init Methoden in beiden gibt. (hier wurde die init Methode der Instanz in initvaria umbenannt)

So habe ich es auf jeden Fall gerade ausprobiert und gesehen. Sollte es jetzt doch anders sein, dann weiß ich auch nicht mehr weiter....

Puh, eigentlich recht einfach, aber wie Du schon erwähntest, nicht ausführlich erklärt, oder aber zu viel Hintergrundwissen vorausgesetzt

Aber auch hier: Nicht zu sehr verrennen, sondern zwischendurch einfach mal nach draußen gehen und frische Luft schnappen.

[Manfred]

Hi alle

hier die Antwort vom Alaska Support

-------------------------------------------------------
Hallo Herr Kunz,

das Verhalten ist korrekt, und per Design.

Es wird vielleicht klarer wenn Sie in die
initclass Methode der Klasse Datenbank
folgendes Einfügen:

? "init class",self:classname()

Sie sehen dann, initclass wird fuer jede Klasse genau
einmalig gerufen wird.

Wenn Sie in der Procedure main die beiden Testfaelle
verdrehen sehen Sie auch das das ganze nicht mit der
Klasse Test oder Test2 zusammenhängt.

Mit anderen Worten, initclass wird fuer jede Klasse
genau einmal gerufen. Ist eine Klasse B aber von
einer Klasse A abgeleitet, so kann das Klassen-Object
der Klasse B nur dann erzeugt werden wenn das
Klassen-Object der Basisklasse (genauer aller Basisklasses)
verfügbar ist. Deshalb kommt es beim erstmalig erzuegen
eines Objectes der Klasse Test, erst zum ausführen von
initclass fuer die Klasse Datenbank, dann zu initclass fuer
die Klasse Test und dann zum erzeugen des Objektes.

Hoffe ich habe mich jetzt nicht zu umständlich ausgedrückt.

Mit besten Grüßen aus Eschborn,
Alaska Technical Support

-------------------------------

hm.....

[Manfred]

Tach,

es ist wohl jetzt ein Ende in Sicht.

Gerade habe ich etwas ausprobiert und bin dann durch genaues Hinsehen mal wieder einen Schritt weitergekommen.

Für die, die es interessiert:

Also, die INITCLASS wird aufgerufen beim ersten Objekt. (bis hier hin wußte ich es )
Wenn ich jetzt ein weiteres Objekt ableite, dann werden die Membervar zwar im weitern neuen Objekt übernommen/übergeben, aber sie haben alle den Wert NIL. Das hat mich gerade etwas gestört. Aber wozu gibt es denn einen Debugger.
Also müßte/muß man ein init() hinterhersetzen, damit die Membervar exakt die Startwerte haben, wie das 1.Objekt, das gebildet wurde.

Code: Alles auswählen

oTest   := test():new()
oTest2 := test():new() <- hier sind die Membervar zwar bekannt, aber NIL

Würde man das anders wollen, dann müßte stehen:

Code: Alles auswählen

oTest := test():new() --> hier wird automatisch die initclass abgearbeitet
oTest2 := test():new():initclass() --> hier muß es nochmals angestoßen werden

ob das jetzt alles im Sinne des Erfinders ist, bzw. so eine glückliche Lösung, .....??? Bzw. ob dieser gewählte Weg überhaupt von den Entwicklern so akzeptiert werden kann, keine Ahnung. Jedenfalls lasse ich es erstmal so.

[Martin Altmann]

Hallo Manfred,
eigentlich sollte es doch ein oTest2 := test():new():create() sein, oder?
Erst, wenn das Objekt angelegt wird, kann es ja auch einen Wert haben.

Viele Grüße,
Martin

[Manfred]

Hi Martin,

verwirre mich jetzt nicht total.
Wenn ich nur :new() aufrufe, habe ich doch alles was ich brauche. Ich bezog mich auf mein anfängliches Beispiel
Wenn ich nach dem new() nochmals ein create() aufrufen, dann wird die init Methode nochmals aufgerufen.....

[Manfred]

ich habe das gerade mal probiert.

oTest := test():new():create() --> init methode wird 2x aufgerufen

oTest2 := test():new():create() --> Fehlermeldung das das Objekt keine create methode hat.

[Martin Altmann]

Hallo Manfred,
sorry - mein Fehler! Ich hatte mir nur Dein aktuelles Posting angeschaut, nicht aber Deine Beispielklasse weiter oben! Und dort hast Du eine Klasse kreiert, die von keiner anderen Klasse abgeleitet ist und tatsächlich kein create() besitzt
Also kannst Du meine Aussage für Dein Beispiel getrost vergessen, sorry!

Viele Grüße,
Martin

[Manfred]

Au weiah,

nimmt das nie ein Ende?

nachdem ich ein 2.Objekt gebildet habe, kann ich damit eine Exported Methode nicht aufrufen.

Access to method not allowed within class-object

Ich verstehe nix mehr.

[Manfred]

Hm,

es hängt mit dem Aufruf von initclass() zusammen. Wenn ich den weglasse, dann steht die Methode zur Verfügung.

[brandelh]

Hallo,

ich kann mich nur wiederholen, normalerweise nimmt man ein normales INIT und das wird automatisch bei jedem neuen Object durchlaufen. Diese haben dann immer die gewünschten init Werte.

[Manfred]

Hi Hubert,

ist ja auch alles verständlich, aber am Anfang des Themas hatte ich aufgezählt warum ich es mache, bzw. womit ich ein Problem habe.

Ich werde um diese Angelegenheit mit initvaria() nicht umhin kommen, wie ich es sehe. Nur würde mich hier interessieren, warum es sich so verhält.

OK, dann erkläre mir doch bitte nochmal wo Du ein init in meinem Fall einsetzen würdest?

[brandelh]

Hallo,

ich nehme mal eine stark vereinfachte Form deiner Datenbank-Klasse.
Ich will keinesfalls behaupten, dass ich ein Guru auf OOP bin, aber ich nehme den einfachen Weg, wenn er zum Ziel führt.

Ich gehe davon aus, bzw. ich habe es so verstanden, dass ...
Du hast eine Klasse, welche eine beliebige DBF verwaltet. Pro DBF brauchst du ein solches Objekt. Jedes dieser Objekte muß selbständig sein und darf sich gegenseitig nicht beeinflussen ... so verhielten sich die DBServer von VO, und die waren wirklich Klasse ...

Code: Alles auswählen

class datenbank
    protected:     // alles was nur meine eigene Klasse was angeht
    VAR nAlias    // alle Aktionen sollen nur über die Klasse gehen, 
                       // also Protected: 

    EXPORTED:  // alle Variablen und Funktionen, welche auch von außen
                      // aufgerufen werden dürfen.
    METHOD INIT
    METHOD USE
    METHOD ACCESS Lastrec    // nur lesen Feld für Lastrec()
endclass
method datenbank:init(cFileName)
    if cFileName=NIL   // kein Dateiname übergeben, später mit ::USE öffnen
    else
       nAlias := ::USE(cFileName)   
    endif
    ...
return self
method datenbank:USE(cFileName)
...

jedes erzeugte Object dieser Classe wird INIT ausführen und eine übergebene Datei öffnen, bzw. alle dort aufgeführten iVars mit Werten vorladen. INITCLASS macht etwas ähnliches, aber nur für das erste Object der Klasse. Wenn man das braucht, ist initclass richtig, wenn man das andere braucht muss man INIT nutzen.

[Manfred]

HH,

so ähnlich habe ich es auch jetzt gemacht. Das mit initclass war halt ein Versuch, aber leider kein erfolgreicher in meinem Fall.

Schade..... ich hatte es eigentlich genau für diesen Fall erwartet, das es dafür geeignet sei. Naja, falsch gedacht.