Vererbung

[Manfred]

Hi Leute,

kann mir jemand dazu etwas genaueres sagen, irgendwie habe ich heute ein Brett vor dem Kopf.

Ist aus der Doku von Xbase++ Thema Class --> SuperClass

schnipp >---------------------------------
Wenn die Klassenvariablen der Superklassen nicht als SHARED deklariert sind, werden sie in der neuen Klasse als Kopien angelegt. Diese Klassenvariablen können durch die Instanzen der Superklassen dann nicht mehr verändert werden, sondern nur noch von Instanzen der neuen Klasse <ClassName> . Wenn Klassenvariablen, in den Superklassen dagegen als SHARED deklariert sind, werden sie gemeinsam verwendet und können sowohl von der neuen als auch von allen beteiligten Klassen verändert werden.

Die Option SHARING ist nur bei mehrfacher Vererbung (multiple inheritance) von Bedeutung und betrifft Member-Variablen der Superklassen mit gleichem Namen bzw. Bezeichner. Falls zwei Superklassen von einer gemeinsamen Klasse abgeleitet sind, wird in der neuen Klasse <ClassName> nur eine Member-Variable angelegt (Näheres dazu findet sich in dem Abschnitt "Vererbung" im Kapitel "Grundlagen der Programmierung mit Objekten").

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

[Manfred]

Ich habe das mit dem Sharing nicht so ganz verstanden, was es wie und wo für ein Resultat ergibt...

[Martin Altmann]

Hallo Manfred,
ich gebe ja immer gerne meinen Senf dazu
Also:
Eigentlich heisst das nichts weiter, als das bei der Angabe von Shared alle (Kinder-)Klassen sich die entsprechende Variable teilen! Wird deren Wert in einer verändert, schlägt diese Änderung auch auf alle anderen sofort durch. Inwieweit dies Sinn macht, hängt natürlich von der jeweiligen Aufgabe ab...
Ein Beispiel (wenn auch nicht sehr sinnvoll) in Pseudocode

Code: Alles auswählen

Class Waehrung
  VAR Kurs
  VAR SHARED Heimatwaehrung

  METHOD umrechnen( Menge )
Endclass

Class Sterling from Waehrung()
Endclass

Class USD from Waehrung()
Endclass

Sterling:Kurs := 1.234
USD: Kurs := 0.987
USD:Heimatwaehrung := "Euro"  // -> Auch Sterling:Heimatwaehrung ist dann "Euro"

Viele Grüße,
Martin

[Manfred]

Hi Martin,

Hallo Manfred,
ich gebe ja immer gerne meinen Senf dazu

ich glaube da hat hier keiner etwas gegen.....

Also:
Eigentlich heisst das nichts weiter, als das bei der Angabe von Shared alle (Kinder-)Klassen sich die entsprechende Variable teilen! Wird deren Wert in einer verändert, schlägt diese Änderung auch auf alle anderen sofort durch. Inwieweit dies Sinn macht, hängt natürlich von der jeweiligen Aufgabe ab...
Ein Beispiel (wenn auch nicht sehr sinnvoll) in Pseudocode

Code: Alles auswählen

Class Waehrung
  VAR Kurs
  VAR SHARED Heimatwaehrung

  METHOD umrechnen( Menge )
Endclass

Class Sterling from Waehrung()
Endclass

Class USD from Waehrung()
Endclass

Sterling:Kurs := 1.234
USD: Kurs := 0.987
USD:Heimatwaehrung := "Euro"  // -> Auch Sterling:Heimatwaehrung ist dann "Euro"

Viele Grüße,
Martin

Ich habe mir den Rest nun doch schon mal durchgelesen.....
Jetzt weiß ich auch, was mich an der ganzen Sache irritiert:

Ich habe ein Problem damit gehabt, als ich eine Klasse von einer anderen Klasse erben ließ. Irgendwie hat es mit der Initialisierung der Membervariablen nicht so geklappt, wie ich es erwartet hatte. Ich meine jetzt von beiden Klassen.

Ich habe jetzt meine Frage oben etwas voreilig gestellt. Ich werde wohl nochmals ganz genau nachlesen müssen und dann die Initialisierung der Klassen(n) ausprobieren. Es klappt jetzt zwar so, wie ich es haben möchte, aber ich bezweifel, dass es im Sinne der OOP gelöst wurde von mir. Ich werde nochmals auf diesen Thread zurückkommen, wenn ich mein Problem damit genauer definieren kann. (Ich habe es nämlich schon wieder vergessen, was es genau war, bzw. was ich erwartet hatte)

[Manfred]

Hi,

ich schreibe es mal hier rein, weil ich denke es gehört noch zur Vererbung:

Nachdem ich nun die Doku gelesen habe, verwirrt mich etwas die Sache mit dem InitClass und dem INIT.

Den direkten Unterscheid habe ich nicht verstanden. Es sieht doch so aus:

Bei beiden ist es doch so, dass, wenn in der Superklasse eine INIT Methode vorhanden ist und in der abgeleiteten nicht, das dann die Init Methode der Superklasse angestoßen wird. Wenn nun die abgeleitete Klasse eine Init hat, dann wird die angestoßen und die der Superklasse muß extra angestoßen werden.

[Lewi]

Hi Manfred,
die Methode "Init" kann als optionale Methode für eine Klasse definiert werden. Diese wird automatisch mit :new() aufgerufen.

Eine Init-Methode ist also nicht zwingend notwendig.

Wird eine Klasse von einer anderen Klasse (Superklasse) abgeleitet, so wird mit :new() eine Instanz von der eigenen Klasse erzeugt und das :new() als Nachricht auch an die Superklasse gesendet. Hat die Superklasse eine Init-Methode, dann wird diese automatisch ausgeführt.

Gruß, Olaf

[Manfred]

Hi Olaf,

das so alles schon klar. Was ich nur nicht ganz nachvollziehen kann, ist das es 2x etwas mit init gibt und auch so in der Doku erklärt wird, wobei ich der Meinung bin, dass beide dasselbe tun.

Deswegen wollte ich wissen, ob jemand mit den beiden verschiedene Erfahrung, bzw. Programmierlösungen gemacht hat.

[Robert]

Was ich nur nicht ganz nachvollziehen kann, ist das es 2x etwas mit init gibt und auch so in der Doku erklärt wird, wobei ich der Meinung bin, dass beide dasselbe tun.

Deswegen wollte ich wissen, ob jemand mit den beiden verschiedene Erfahrung, bzw. Programmierlösungen gemacht hat.

Hallo Manfred,

der eigentliche Unterschied zwischen init und initclass ist der, dass initclass nur einmal aufgerufen wird, egal wieviele Objekte du erzeugst.

Das dient dazu um evtl. Klassenvariablen zu initialisieren.


Bsp:

Code: Alles auswählen

CLASS foo
   EXPORTED:

    CLASS VAR clsV
               VAR nV

    CLASS METHOD initClass
               METHOD init
ENDCLASS

CLASS METHOD foo:initClass
      ::clsV := 1
RETURN self

METHOD foo:init
    ::nV   := 1
RETURN self

Egal wieviele Instanzen du nun von foo erzeugst, initClass wird nur ein einziges Mal aufgerufen, da sich alle Objekte alle Klassenvariablen teilen (in diesem Fall clsV).

init hingegen wird bei jeder Instanzierung aufgerufen, da jedes Objekt seine eigenen Attribute (oder wie man in Xbase so schön sagt, Instanzvariablen, in diesem Fall nV) hat.

edit: das Zitieren schein hier nicht richtig zu funktionieren?

[Manfred]

Hallo Robert,

das habe ich jetzt rein leserisch verstanden. Ich werde mir aber dazu wohl nochmals ein eigenes Beispiel bauen und über den Debugger ansehen müssen. Ich verstehe nämlich im Moment auch den Sinn und Zweck nicht so richtig, sprich gar nicht. Das heißt aber nichts.

Zitat klappt nicht?

doch....

Zitat

es muß nur ein Ende gezeigt werden ein quote mit Slash davor.

[Robert]

Hallo Robert,

Ich verstehe nämlich im Moment auch den Sinn und Zweck nicht so richtig, sprich gar nicht. Das heißt aber nichts.

initClass hat findent seinen Sinn und Zweck im Zusammenhang mit Klassenvariablen.

Damit kann man zum Beispiel kontrollieren, wieviele Objekte von einer Klasse erzeugt wurden, oder wiviele maximal erzeugt werden dürfen.

Mittels Klassenmethode initClass könntest du so einen Objektzähler initialisieren - das geschiet einmalig bei der aller ersten Instanzierung.
Jedes Objekt teilt sich dann den Objektzähler.

Die Methode init kann diesen Objektzähler inkrementieren. Da init bei jeder Instanzierung (und nicht nur bei der ersten) aufgerufen wird, weißt du am Ende genau, wieviele Objekte der Klasse erzeugt wurden.

Sowas wäre zum Beispiel ein möglicher Nutzen des Ganzen.

Vielleicht hats ja irgenwie ein bisschen Licht ins Dunkel gebracht?

wenn ich ohne Namen zitiere Klappts...

[Manfred]

Hi Robert,

wie sagt Herbert Knebel immer so schön: "Datt is' n Aggement".

OK, so kann ich die Dinge besser einsortieren und zumindest eine Anwendung damit verstehen.

Muß ich mir durch den Kopf gehen lassen......

Thx

PS: war das jetzt nur ein lockeres Beispiel, oder gibt es da Beschränkungen bei der Erzeugung von Objekten?

[Robert]

PS: war das jetzt nur ein lockeres Beispiel, oder gibt es da Beschränkungen bei der Erzeugung von Objekten?

Eigentlich gibt es keine Beschränkung, wieviele Objekte du erzeugen kannst, mal abgesehen vom verfügbaren Speicher.

Die Nutzung von der o.g. Methode ist dann Programmabhängig. Z.B. kann man wollen, dass immer nur ein Fenster der selben Klasse geöffnet ist und verweigert somit das erzeugen weiterer Fenster, bis eins geschlossen wurde.

[Manfred]

Die Nutzung von der o.g. Methode ist dann Programmabhängig. Z.B. kann man wollen, dass immer nur ein Fenster der selben Klasse geöffnet ist und verweigert somit das erzeugen weiterer Fenster, bis eins geschlossen wurde.

Aaaaahhh,

jetzt fällt der Euro centweise. (Hier denke ich schon komplett in der "neuen" Währung ) Damit kann ich jetzt richtig etwas anfangen. Klar, im nachhinein gesehen, logisch.

Ich habe noch nicht soviel praktische Erfahrung mit der OOP. Deshalb brauche ich auch immer Beispiele um zu verstehen WARUM es so ist. Ansonsten nehme ich es hin, aber kann es nicht umsetzen.

jaja, jede Jeck iss anders

[Lewi]

Was ich nur nicht ganz nachvollziehen kann, ist das es 2x etwas mit init gibt und auch so in der Doku erklärt wird, wobei ich der Meinung bin, dass beide dasselbe tun.

Deswegen wollte ich wissen, ob jemand mit den beiden verschiedene Erfahrung, bzw. Programmierlösungen gemacht hat.

Hallo Manfred,

der eigentliche Unterschied zwischen init und initclass ist der, dass initclass nur einmal aufgerufen wird, egal wieviele Objekte du erzeugst.

Das dient dazu um evtl. Klassenvariablen zu initialisieren.


Bsp:

Code: Alles auswählen

CLASS foo
   EXPORTED:

    CLASS VAR clsV
               VAR nV

    CLASS METHOD initClass
               METHOD init
ENDCLASS

CLASS METHOD foo:initClass
      ::clsV := 1
RETURN self

METHOD foo:init
    ::nV   := 1
RETURN self

Egal wieviele Instanzen du nun von foo erzeugst, initClass wird nur ein einziges Mal aufgerufen, da sich alle Objekte alle Klassenvariablen teilen (in diesem Fall clsV).

init hingegen wird bei jeder Instanzierung aufgerufen, da jedes Objekt seine eigenen Attribute (oder wie man in Xbase so schön sagt, Instanzvariablen, in diesem Fall nV) hat.

edit: das Zitieren schein hier nicht richtig zu funktionieren?

**********************************************************************

Hallo Robert,
Deine Aussage, dass für alle Instanzen einer Klasse ( d.h. Objekte der instanzierten Klasse) die definierte Klassen-Methode "CLASS METHOD INITCLASS" nur "einmalig", also unabhängig davon, wie viele Instanzen dieser Klasse erzeugt werden, ist falsch.

Ohne an dieser Stelle das Thema "Überladung von Klassen-Methoden mit in die Diskussion einzubeziehen, ist es so, dass mit Erzeugung eines Objektes einer Klasse über "oObj := Klassenname:new()" der Programmcode der Klasse einschließlich seiner Superklassen diesem Objekt "zugeordnet" wird und die Methoden "CLASS METHOD INITCLASS" bzw. "Method INIT() jedes mal automatisch ausgeführt werden, wenn diese deklariert wurden.

In Deinem Beispiel würde die Membervariable "::clsV" bei Erzeugung einer Instanz der Klasse "foo" über "oObj := foo:new()" den Wert "1" haben.

Beispiel:

Func Main()
Local obj1 := foo:new()
Local obj2 := foo:new()
? obj1:clsV // 1
? oBj2:clsV // 1

Return ( NIL )


Nach der OOP-Therorie sind Membervairbalen eines Klassenobjektes nach außen hin gekapselt, d. h. sie gelten nur innerhalb eines Klassenobjektes unter Berücksichtigung der Sichtbarkeitsattribute. Analog gilt dies auch für Klassenmethoden. Wie unter Berücksichtigung dieser Doktrin der Kapselung ein Klassenobjekt feststellen kann, ob es bereits instanziert wurde, um beispielsweise einen Mehrfachaufruf einer Klasse zu verhindern, ist mir ein Rätzel. Dies wäre nur unter dem Einsatz von Public-Variablen möglich.

[Robert]

Hallo Robert,
Deine Aussage, dass für alle Instanzen einer Klasse ( d.h. Objekte der instanzierten Klasse) die definierte Klassen-Methode "CLASS METHOD INITCLASS" nur "einmalig", also unabhängig davon, wie viele Instanzen dieser Klasse erzeugt werden, ist falsch.

ich habs doch extra vorher auch ausprobiert:

Code: Alles auswählen

CLASS foo 
   EXPORTED: 

    CLASS VAR clsV 
          VAR nV 

    CLASS METHOD initClass 
               METHOD init 
ENDCLASS 

CLASS METHOD foo:initClass 
      ::clsV := 1 
     ? "ich bin initclass"
RETURN self 

METHOD foo:init 
    ::nV   := 1 
     ? "ich bin init"
RETURN self

PROCEDURE MAIN

  local obj, obj2

  obj:=foo():new()
  obj2:=foo():new()

RETURN 

Als ausgabe hast du:

ich bin initClass
ich bin init
ich bin init

In Deinem Beispiel würde die Membervariable "::clsV" bei Erzeugung einer Instanz der Klasse "foo" über "oObj := foo:new()" den Wert "1" haben.

Beispiel:

Func Main()
Local obj1 := foo:new()
Local obj2 := foo:new()
? obj1:clsV // 1
? oBj2:clsV // 1
Return ( NIL )

Naja ist doch auch richtig. clsV wurde einmal inititialisiert und liegt, da es eine Klassenvariable (keine Instanzvariable) im Gültigkeitsbereich alle Objekte - obj1 und obj sehen clsV mit dem selben Wert, wohingegen nV
für obj1 und für obj2 unterschiedlich sein können.

[Lewi]

Hallo Robert,
nachdem ich in den letzten 3 Jahren fast 1 Mio. Zeilen Objekt-Code programmiert habe und glaube, eigentlich sattelfest im OOP-Thema zu sein, muß ich konstantieren, dass ich mit meinem Beitrag zum Thema "Class Method InitClass" "wider besseren Wissens" teilweise falsch gelegen habe. (Asche auf mein Haupt)

Also, Robert hat Recht. Die Klassenmethode "CLASS METHOD INITCLASS" wird tatsächich nur ein einziges Mal aufgerufen. Auf der Suche nach dem "warum" und einer Antwort bin auf die Klasse "Abstract()" gestoßen. Die Beschreibung in der xbase++ Hilfe macht den Umstand deutlich, warum sich Roberts Code-Beispiel so verhält.

Die Klasse "Abstract()" ist eine Schnittstelle zu allen Klasse und sozusagen eine "Sammelstelle" für alle Klassen. Diese Klasse weiß sozusagen über die Existenz von instanzierten Klassen.

Die Klasse "Abstract()" ist also dafür verantwortlich, dass die Klassenmethode "CLASS METHOD INITCLASS" nur ein einziges Mal für eine Klasse aufgrufen wird, egal wieviele Instanzen von dieser Klasse gebildet werden.

Gruß, Olaf

[Manfred]

Hallo, ich bin es nochmal

ich habe m.E. das oben genannte Beispiel umgesetzt und dabei festgestellt, das die METHODE Classinit mehrmals aufgerufen wird.

Ich werde einmal ein Beispiel bringen, vielleicht liege ich ja auch total daneben:

Code: Alles auswählen

Class datenbank
         PROTECTED:
         CLASS VAR cVerzeichnis

         EXPORTED:
         CLASS VAR id,;
                           cDbank,;
                           cSuffix

         CLASS METHOD initClass
Endclass

CLASS METHOD datenbank:initClass
                        ::id := 0
                        ::cSuffix := ".dbf"
RETURN self

CLASS test FROM datenbank
           EXPORTED:
           VAR name

           METHOD init
ENDCLASS

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

CLASS test2 FROM datenbank
           EXPORTED:
           VAR name

           METHOD init
ENDCLASS

METHOD test2:init
             ::cDbank := "test"
RETURN self

oTest := test():new()

wenn ich mir die Erzeugung von oTest im Debugger unter VX ansehe, dann wird die METHODE classinit von datenbank 2x nacheinander aufgerufen. Ist das so richtig? Und wenn ja, warum?

Weiterhin habe ich gerade noch ein

Code: Alles auswählen

oTest2 := test2():new()

hinzugefügt. Die initClass wird dann auch wieder erneut aufgerufen.. Aber diesmal nur 1x.

Ich glaube ich habe nichts von dem was oben erklärt wurde verstanden, oder?

[Lewi]

Hi Manfred
wenn Du ein "MsgBox("INITCLASS DATENBANK")" innerhalb der Method "CLASS METHOD INITCLASS" einfügst, dann wirst du feststellen, dass die MsgBox() nur einmal angezeigt wird.

Aber, wenn du eine zweites Instanz von Test() anlegst, wird die Msgbox 2x angezeigt. Warum? Weil "METHOD CLASS METHOD" in der Subklasse "Test()) nicht definiert ist und implizit die Methode der Superklasse "Datenbank()" ausgeführt wird. Das ergibt sich aus der Logik der Klasse "Abstract()"

Gruß, Olaf

[Manfred]

Boh ey, ich glövet nit,

jetzt werde ich mir den ganzen Mist in der Doku nochmals durchlesen.

Bis später

[Manfred]

Hi Olaf,

jetzt muß ich mich mal ganz doof stellen...... (wehe hier kommt ein gemeiner
Kommentar)

wieso eine 2. Instanz von test() ?

[Lewi]

jetzt muß ich mich mal ganz doof stellen...... (wehe hier kommt ein gemeiner
Kommentar)

wieso eine 2. Instanz von test() ?

Ich meinte das wie folgt:

Code: Alles auswählen

Func Main()
    Local oObj1 := Test():New()
    Local oObj2 := Test():New() <----------- 2te Instanz
Return NIL

Gruß, Olaf
PS: Das QUOTEN werde ich wohl nie begreifen // Nachtrag: Ah, jetzt ist der Stein gefallen.

[Manfred]

nönö,

da steht oTest2 := test2():new()

häh, doch nicht doof...... Puh, nochmal Glück gehabt..

Quoten geht : Eckige Klammer auf, quote rein, eckige Klammer zu.

Text

Eckige Klammer auf Backslash quote eckige Klammer zu

[Martin Altmann]

Hallo Olaf,

PS Das QUOTEN werd ich wohl nie begreifen!

keine Sorge, da gibt es eigentlich nichts zu begreifen - es funktioniert im Moment nicht so richtig! Tom dachte, es läge an dem Mod, den er eingespielt hat (Farben in den CODE-tags), aber das war nicht die Ursache. Er weiß aber inzwischen, woran es liegt und braucht nur noch ein wenig Zeit, um es zu korrigieren.
Dein Fehler eben war einfach: Du hattest zwar hinter dem ersten Quote-Tag den Namen entfernt, aber das =-Zeichen stehengelassen

Viele Grüße,
Martin

[Lewi]

nönö,

da steht oTest2 := test2():new()

häh, doch nicht doof...... Puh, nochmal Glück gehabt..

Hi Manfred,
meine Antwort bezog sich auf Dein 1.Code-Beispiel, nicht auf das 2.te

[Manfred]

OK, na gut,

hier nun das was ich ausprobiert habe komplett....

Code: Alles auswählen

Class datenbank
         PROTECTED:
         CLASS VAR cVerzeichnis

         EXPORTED:
         CLASS VAR id,;
                           cDbank,;
                           cSuffix

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

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

           METHOD init
ENDCLASS
**************************************
METHOD test2:init
             ::cDbank := "test"
RETURN self
**************************************
**************************************
PROCEDURE main()
oTest := test():new()      // hier wird die initclass 2x aufgerufen
oTest2 := test2():new()  // hier nur 1x
return