Question

I am playing about with Mootools class inheritance etc and I am trying to call the base classes overridden methods with the .parent property (sry for the long code snippet).

var app = this.app = {},
    //ultimate base class
    Animal = new Class({
        initialize : function(param){
            this.age = param.age;
            this.name = param.name;
        },
        doStuff : function(param){
            alert("animal doStuff");
        }
    }),
    //herbivore functionality
    HerbivoreBehaviour = new Class({
        eat : function(){
            alert('Plants are scrumptious');
        }
    }),
    //carnivore functionality
    CarnivoreBehaviour = new Class({
        eat : function(){
            alert('Meat tastes gooood');
        }
    })
    //mammal base class
    Mammal = new Class({
        Extends : Animal,
        initialize : function(param){
            this.parent(param);
            this.numberOfNipples = param.numberOfNipples;
        },
        doStuff : function(){
            alert("mammal doStuff");
            this.doStuff.parent();
        }
    }),
    //reptile base class
    Reptile = new Class({
        Extends : Animal,
        initialize : function(param){
            this.parent(param);
            this.numberOfScales = param.numberOfScales;
        },
        doStuff : function(){
            alert('reptile doStuff');
            this.doStuff.parent();
        }
    }),
    //final top class animal->mammal-cow!
    //and it's a herbivore
    Cow = new Class({
        Extends : Mammal,
        Implements : HerbivoreBehaviour,
        initialize : function(param){
            this.parent(param);
            this.isMooCrazy = param.isMooCrazy;
        },
        doStuff : function(){
            alert('I am a cow');
            this.doStuff.parent();
        }
    }),
    //final top level class animal->reptile->mutantLizard!
    //and it's a carnivore
    MutantLizard = new Class({
        Extends : Reptile,
        Implements : CarnivoreBehaviour,
        initialize : function(param){
            this.parent(param);
            this.isDestroyingEverything = param.isDestroyingEverything;
        },
        doStuff : function(){
            alert('STOMP STOMP STOMP CRRRRRASH');
            this.doStuff.parent();
        }
    });

    app.run = function(){
        var daisy = new Cow({
                name : 'Daisy',
                age : 2,
                numberOfNipples : 6,
                isMooCrazy : true
            }),
            godzilla = new MutantLizard({
                name : 'Godzilla',
                age : 1123,
                numberOfScales : 123456,
                isDestroyingEverthing : true
            });

        daisy.eat();
        godzilla.eat();
        daisy.doStuff();
        godzilla.doStuff();
    };

the current output is correct from daisy.eat() and godzilla.eat() but then execution stops after the first print statement from daisy.doStuff() it doesn’t then call daisies parent class doStuff() method which is what I was hoping for. Could you tell me how I would call doStuff like this?

UPDATE:

I managed to fix he call sequence by replacnig this.doStuff.parent() with this.parent(). However this raised the question as to what ‘this’ is reffering to. I thought it would be the actual instance of the class ie. daisy or godzilla, but the use of this.parent() in the doStuff method would seem to imply, to me atleast, that ‘this’ is referring to the actual Function object which it is currently inside, unless calling the parent() method inside a function automatically looks for what method you are in and calls it’s first overridden method.

Answer 1

right. well basically, all is good, that’s the good news. the only change required is swapping your this.doStuff.parent() to this.parent() all around.

http://jsfiddle.net/dimitar/njQBN/

seems to work fine.

doing this.doStuff.parent() is not very DRY to begin with, and it also references a local property – which in the context of a class that Extends and Implements others with the same method – at the same time, will have … unexpected results.