Simple JavaScript inheritance

First off, this code is a bit hard to follow and certainly not a conventional way of doing things in Javascript. Can you explain why you've chosen such a unique way to do it? What advantages are you seeking by doing it differently than one of the more "classic" and common and known ways of doing it?

Several comments:

1. Object.create() is preferred for creating the object to assign to your subclass prototype rather than using new as it has fewer side effects (e.g. it doesn't run the constructor).

2. Your code won't run in strict mode because of the use of .callee. Writing your code to be "strict mode safe" has a lot of benefits and no downsides that I know of.

3. Your comments lead me to believe that you think you don't have to call parent constructors if there are no constructor arguments, but that is not necessarily the case.

4. You appear to be attempting to make javascript inheritance look and work like inheritance in other languages. In my experience (I initially went this route too), that is a mistake. Javascript is a prototype-based language. It works differently than languages like C++ and Java and trying to make it look like a non-prototype-based language is not the right approach in the long run. It may feel more familiar in the short run to someone learning javascript, but in my opinion, that is not the real goal here and as soon as you feel more comfortable with how Javascript works, you won't feel like making JS look like some other language is the goal.

5. Your code example seems to be avoiding using the object prototype for methods. There are some advantages to using the prototype. I'd suggest you read here and here and here.

Here's a fairly simple method of inheritance done a more common way in javascript, defining the constructor, putting methods on the prototype, setting up the inheritance, etc...). That's how a prototype-based language generally works. I use one utility function here to reuse some common elements of inheriting.

Working demo: http://jsfiddle.net/jfriend00/6m5Kg/

// utility function to set up prototype-based inheritance
// so one object can inherit from another
function inherit(base, derived, methods) {
    derived.prototype = Object.create(base.prototype);
    derived.prototype.constructor = derived;

    for (var name in methods) {
        if (methods.hasOwnProperty(name)) {
            derived.prototype[name] = methods[name];
        }
    }
}

// define base object
function Human(firstName, lastName) {
    // code here to initialize instance data
    this.firstName = firstName;
    this.lastName = lastName;
}

Human.prototype = {
    getName: function() {
        return this.firstName + " " + this.lastName;
    },
    setName: function(firstName, lastName) {
        // set name component if it was passed
        if (firstName) {
            this.firstName = firstName;
        }
        if (lastName) {
            this.lastName = lastName;
        }
    }
}

// define derived object constructor
function European(firstName, lastName, middleName) {
    Human.call(this, firstName, lastName);
    this.middleName = middleName;
}

// inherit from Human object
inherit(Human, European, {
    // override replacement
    getName: function() {
        return this.firstName + " " + this.middleName + " " + this.lastName;
    },
    //override with calling base method - adds one new argument
    setName: function(firstName, lastName, middleName) {
        // call base method
        Human.prototype.setName.call(this, firstName, lastName);
        if (middleName) {
            this.middleName = middleName;
        }
    }
});

This uses Object.create() for assigning to the prototype to avoid any constructor side effects. Object.create() is supported in IE9 and above. If you want to supprt earlier versions of IE, you can use the polyfill for Object.create() here.