var Human = MG.Class.Create({

Gender: null,

constructor: function(gender) {

this.Gender = gender;

},

GenderString: function() {

return this.Gender == ‘F’ ? “female” : “male”;

},

ToOverride: function() { return “Called from Human”; }

}, null, null);

var Individual = MG.Class.Create({

Unique: null,

constructor: function(unique) {

this.Unique = unique;

},

IsUnique: function() {

return this.Unique ? “Yes” : “No”;

},

ToOverride: function() { return “Called from Individual which is ” + (this.Unique ? “unique” : “not unique”) + ” / ” + this.base(); }

}, Human, null);

var objHuman = new Human(”F”);

var objIndividual = new Individual(true, “M”);

In my opinion also a check for parameters of the base constructor should be added. If the derived object does not provide on instantiation the correct number or parameters for the base, then an exception should be triggered.

Reusing code is a state of mind. Most programmers writing a solution to the problem only and do this over and over again for each project. Paste and copy is not the same, and also reinventing the wheel is not the same. Most solutions are based upon the same with a little difference. To write such *open* classes (and use it successfully) you must understand real OOP and what you really can do with it. The order and open construction of it is very important. Most of the javascript programmers/(especially)webdesigners doesn’t have this challenge (sorry to say). It is not difficult but it is another way of thinking to develop robust solutions on the long term.

To give you any idea (because i don’t give the code away at this moment), after the main class (class_object.js) is loaded you can do such things as:

function CMyClass( oData )
{
var myProperty1 = “Hello”;
var myProperty2 = “World”;

objectExtend( this, “CObject”, arguments, oData ); // Extend it
}

CMyClass.prototype.__construct = function() // overwrite constructor
{
this.inherited(arguments); // call inherited constructor CObject.__construct()
this.installCss( “mycss.css”, “css/” );
}

CMyClass.prototype.installCss = function( asFileName, sBasepath, sMedia, bAppendToBody )
{
if( sMedia == undefined )
{ var sMedia = “screen”; }
this.inherited(arguments);
}

// Create the class
var oExample = new CMyClass({onCreate:function(oSender) {alert(“created “+this.className+this.myProperty1+” “+this.myProperty1);}});

When the object is created it will show an alertbox with the text “CMyClass Hello World” and loads the stylesheet css/mycss.css”. NOTE: “this” is the object, because there is also a “call in scope construction” for events.

As you can see, it is possible to do!

JavaScript “like Java”.

var ClassA = Class.create(“ClassA”,function(){

var value = “value:A”;
this.getValue = function(){
return value;
};
this.$$constructor = function(){
};

});

var ClassB = Class.extend(“ClassB”,ClassA,function(){

var value = “value:B”;
this.getValue = function(){
return value + ” ” + this.$$super[0].getValue();
};
this.$$constructor = function(){
};

});

var instB = new ClassB();
alert(instB.getValue());// value:B value:A

You can see more examples in http://www.jsimpleclass.net/

Bye

SOLUTION: Parasitic inheritance using Douglas Crockford’s object function and Power Constructor pattern. See Advanced JavaScript video 1 at http://developer.yahoo.com/yui/theater/

But I’m quite sure that your approach is closer to a prototypal approach.

Won’t something like,

Mammal.Run.call(catInstance);

do the trick. Or if you’re in a Cat instance (and say want to extend the super-class)

Cat.prototype.Run = function()
{
Mammal.Run.call(this);
// Do more stuff
}

I you ever write something on mixin, send me a mail and I’ll try to link to it in a elegant way!

Thanks

I still haven’t completely exploited the full potential of mixins, but I think it’s a path worth exploring… Perhaps I should write about this somewhere to illustrate what I have in mind and stimulate conversation…

Finally, I just want to clear out that I didn’t intend to start a debate about OO vs. prototyping, but rather a discussion about how we can best marry the two.