Vererbung

[peterS.]

gruss molily,

function Menschenartiger (Name) {
  this.Name = Name;
}
function Menschenaffe (Name) {
  this.constructor(Name);
}
Menschenaffe.prototype = new Menschenartiger();
...

/*
   zur rekapitulation (fuer mich und andere?) -

bis hierher passiert folgendes:

der prototyp des konstruktors "Menschenaffe" und damit auch der
   prototyp jedes objekts vom typ "menschenaffe" ist ein objekt vom
   typ "menschenartiger" mit der undefinierten eigenschaft "Name".

die eigenschaft "Name" eines "bonobo"-objektes -

var bonobo = new Menschenaffe("bonobo");

- wird zunaechst vom prototypen des objektes bestimmt und ist
   wegen  "Menschenaffe.prototype = new Menschenartiger()"
   unmittelbar am anfang des konstruktoren-aufrufs noch "undefined".
   der konstruktor "Menschenaffe" definiert selbst keine "Name"-
   eigenschaft fuer objekte vom typ "menschenaffe", sondern reicht
   das "Name"-argument wiederum nur an seinen eigenen prototypen-
   konstruktor ("Menschenartiger") weiter. erst an dieser stelle
   der konstruktionskaskade bekommt ein jedes "menschenaffe"-objekt
   seine eigene "Name"-eigenschaft zugewiesen.
 */

...
function EchterMensch (Name) {
  this.constructor(Name);
}
EchterMensch.prototype = new Menschenaffe();

function Mensch (Name) {
  this.constructor(Name);
}
Mensch.prototype = new EchterMensch();

var molily = new Mensch("Mathias");

alert(molily.Name);

...
Ferne frage ich mich, ob das doppelte Aufrufen des Prototyp-
Konstruktors (new EchterMensch() und this.constructor(Name))
einmal mit und einmal ohne Parameter in der Praxis bei
komplexeren Anwendungen Probleme verursachen kann. Falls ja,
müsste man tatsächlich das Setzen von Eigenschaften anhand
der Parameter in jeder Konstruktorfunktion wiederholen.

mit der von Dir im beispiel gewaehlten vorgehensweise bleibst
   Du beschwerdefrei - komplexere Anwendungen verlangen dann
   moeglicherweise nach einem voellig anderen aufbau der
   konstruktoren.

Ist das gängige Praxis?

was praxis ist, weiss ich nicht - ich implementiere zueinander
   in beziehung stehende konstruktoren jedesmal ein wenig anders.

das schoene an javascript ist, dass Du beim stricken von
   komplexen oo-anwendungen ohne einengendes klassen-korsett
   arbeiten darfst. oder anders: kein formalismus nimmt Dich
   an die hand, um Dir den weg aus dem vererbungs-labyrinth
   zu weisen.

Dein beispiel wuerde ich so umsetzen:

var Menschenartiger = function (name) {
     this.name = name;
   };
   var Menschenaffe = function (name) {
     this.constructor = arguments.callee; // ueberschreibt "Menschenartiger";
     this.name = name;
   };
   Menschenaffe.prototype = new Menschenartiger("Menschenaffe");

var EchterMensch = function (name) {
     this.constructor = arguments.callee; // ueberschreibt "Menschenaffe";
     this.name = name;
   };
   EchterMensch.prototype = new Menschenaffe("EchterMensch");

var Mensch = function (name) {
     this.constructor = arguments.callee; // ueberschreibt "EchterMensch";
     this.name = name;
   };
   Mensch.prototype = new EchterMensch("Mensch");

var molily = new Mensch("Mathias");

alert("molily.name = " + molily.name +
     "\n\nmolily.constructor = " + molily.constructor +
     "\n\n(molily.constructor === Mensch) ? " + (molily.constructor === Mensch) +
     "\n(molily.constructor === EchterMensch) ? " + (molily.constructor === EchterMensch) +
     "\n(molily.constructor === Menschenaffe) ? " + (molily.constructor === Menschenaffe) +
     "\n(molily.constructor === Menschenartiger) ? " + (molily.constructor === Menschenartiger) +
     "\n\n(molily instanceof Mensch) ? " + (molily instanceof Mensch) +
     "\n(molily instanceof EchterMensch) ? " + (molily instanceof EchterMensch) +
     "\n(molily instanceof Menschenaffe) ? " + (molily instanceof Menschenaffe) +
     "\n(molily instanceof Menschenartiger) ? " + (molily instanceof Menschenartiger)
   );

by(t)e by(t)e - peterS. - [e-mail]