Object.prototype.ext = function(construct, args){
  construct.apply(this, args);
  this._prototypes.push(construct);
}

Object.prototype.instanceOf = function(className){
  if(this.constructor.name===className) return true;
  if(typeof(this._prototypes)==='undefined') return false;
  var res = false;
  for(var i=0; i<this._prototypes.length; i++){
    if(this._prototypes[i].name===className){
      res=true;
      break;
    }
  }
  return res;
}

function validateArguments(num, types, args){
  if(args.length<num){
    throw new Error('too few arguments in function '+args.callee.name);
  }
  if(args.length>num){
    throw new Error('too many arguments in function '+args.callee.name);
  }
  for(var i=0; i<args.length; i++){
    if(!args[i].instanceOf(types[i]))
      throw new Error('argument number '+(i+1)+' in function must be a '+types[i]+' but '+args[i].constructor.name+' is given');
  }
}

function TObject(){
  this._prototypes=[];
}

function MyTestObject(){
  this.ext(TObject, []);
  this.tryVal = function tryVal(a1, a2, a3){
    validateArguments(3, ['String', 'Number', 'TObject'], arguments);
  }
}
var t = new MyTestObject();
t.tryVal(10,'hi', t);

Object.prototype.validateArguments = function(types, func){
  var obj = this;
  return function(){
    if(arguments.length<types.length){
      throw new Error('too few arguments in function '+func.name);
    }
    if(arguments.length>types.length){
      throw new Error('too many arguments in function '+func.name);
    }
    for(var i=0; i<arguments.length; i++){
      if(!arguments[i].instanceOf(types[i]))
        throw new Error('argument '+(i+1)+' in function '+func.name+' must be a '+types[i]+' but '+arguments[i].constructor.name+' is given');
    }
    func.apply(obj, arguments);
  }
}

function MyTestObject(){
  this.ext(TObject, []);
  this.tryVal = this.validateArguments(
    ['String', 'Number', 'TObject'], function tryVal(a1, a2, a3){
    }
  );
}

class Animal{
  public:
    Animal(int legs){
      this->legs = legs;
    }
    int getLegs(){
      return this->legs;
    }
  private:
    int legs;
}

class Rabbit: public Animal{
  public:
    Rabbit(int jumpLength): Animal(4){
      this->jumpLength = jumpLength;
    }
  private:
    int jumpLength;
}
class Human: public Animal{
  public:
    Human(int height): Animal(2){
      this->height = height;
    }
  private:
    int height;
}
class Bird: public Animal{
  public:
    Bird(bool canFly, int legs): Animal(legs){
      this->canFly = canFly;
    }
  private:
    bool canFly;
}

Bird b = new Bird(true, 2);
cout << b.getLegs();

Object.prototype.ext = function(construct, args){
  construct.apply(this, args);
  this._prototypes.push(construct);
}

Object.prototype.instanceOf = function(className){
  if(this.constructor.name===className) return true;
  if(typeof(this._prototypes)==='undefined') return false;
  var res = false;
  for(var i=0; i<this._prototypes.length; i++){
    if(this._prototypes[i].name===className){
      res=true;
      break;
    }
  }
  return res;
}

Object.prototype._ = function(types, func){
  var obj = this;
  this[func.name] = function(){
    var err = TypeError();
    var trace = err.stack.split("\n").slice(3).join("\n");
    if(arguments.length<types.length){
      err.message = 'too few arguments in function '+obj.constructor.name+'.'+func.name+"\n"+trace;
      throw err;
    }
    if(arguments.length>types.length){
      err.message = 'too many arguments in function '+obj.constructor.name+'.'+func.name+"\n"+trace;
      throw err;
    }
    for(var i=0; i<arguments.length; i++){
      if(!arguments[i].instanceOf(types[i])){
        err.message = 'argument '+(i+1)+' in function '+obj.constructor.name+'.'+func.name+' must be a '+types[i]+' but '+arguments[i].constructor.name+" is given\n"+trace;
        throw err;
      }
    }
    func.apply(obj, arguments);
  }
}

Object.prototype.__ = function(types, func){
  var obj = this;
  var f = this[func.name];
  this[func.name] = function(){
    var fail = false;
    var err = TypeError();
    var trace = err.stack.split("\n").slice(3).join("\n");
    try{
      var argsType = [];
      for (var i=0; i<arguments.length; i++){
        argsType.push(arguments[i].constructor.name);
      }
      if(arguments.length<types.length){
        err.message = "there are no method "+obj.constructor.name+'.'+func.name+"("+argsType.join(", ")+")\n"+trace;
        throw err;
      }
      if(arguments.length>types.length){
        err.message = "there are no method "+obj.constructor.name+'.'+func.name+"("+argsType.join(", ")+")\n"+trace;
        throw err;
      }
      for(var i=0; i<arguments.length; i++){
        if(!arguments[i].instanceOf(types[i])){
          err.message = "there are no method "+obj.constructor.name+'.'+func.name+"("+argsType.join(", ")+")\n"+trace;
          throw err;
        }
      }
    }catch(err){
      fail = true;
      if(typeof(f)!=='undefined'){
        f.apply(obj, arguments);
      }else{
        throw err;
      }
    }
    if (!fail) func.apply(obj, arguments);
  }
}

function TObject(){
  this._prototypes=[];
}

function MyTestObject(){
  this.ext(TObject, []);
  this._(['String', 'Number', 'TObject'], function tryVal(a1, a2, a3){
    alert('hi');
  });
  
  this.__(['String', 'Number', 'TObject'], function try2(a1, a2, a3){
   alert('hi');
  });
  
  this.__(['String'], function try2(a1){
     alert('hello');
  });
}
var t = new MyTestObject();
t.try2('hi', 10, t, t);

var Parent = function( data ) {
    this.data = data || false;
    this.public_method = function() { return 'Public Method'; }
}
 
var Child = function() {
    this.public_method = function() { return 'Redefined public method'; }
    this.getData = function() { return 'Data: ' + this.data; }
}
 
Child.prototype = new Parent('test'); //суть прототипного наследования
var Test = new Child();
 
Test.getData(); // => "Data: test"
Test.public_method(); // => "Redefined public method"
Test.data; // => "test"

function MyTestObject(){
  this.ext(TObject, []);
  this._(['String', 'Number', 'TObject'], function tryVal(a1, a2, a3){
    alert('hi');
  });
  
  this.__(['String', 'Number', 'TObject'], function try2(a1, a2, a3){
   alert('hi');
  });
  
  this.__(['String'], function try2(a1){
     return a1;
  });
}

var t = new MyTestObject();
alert(t.try2('hello', 'hi'));

function MyTestObject(){
  this.ext(TObject, []);
  
  this.__(['String', 'Number'], function try2(a1, a2){
   return a1+a2;
  });
  
  this.__(['String'], function try2(a1){
     return a1;
  });
  
  this._(['Number'], function onlyValidate(num){
     return num*2;
  })
}

function Child(){
  this.ext(MyTestObject, []);
  
  var parentTry2 = this.try2;
  this.__(['String', 'Number'], function try2(a1, a2){
    return parentTry2(a1, a2*2);
  })
}

var t = new Child();
alert(t.try2('hello'));
alert(t.try2('hello', 10));
alert(t.onlyValidate(8));
t.try2(1, 2);

this.ext(TObject, []);
  this._(['String', 'Number', 'TObject'],

function Animal(Legs) {
	this.legs=calcLegs(Legs);
	this.getLegs=function() {
		alert(this.legs);
	};
	function calcLegs(Legs){
		return Legs+' шт.';
	};
};
function Bird(Legs,canFly) {
	Animal.apply(this,arguments);
	this.canFly=canFly;
};
Bird.prototype = new Animal();
griffin = new Bird(4,true);
griffin.getLegs();
alert(griffin.canFly);
chicken = new Bird(2,false);
chicken.getLegs();
alert(chicken.canFly);