function extend(s, c) {
  function f() {};
  f.prototype = s.prototype; //sはインスタンスでは無く、型でなければだめ
  c.prototype = new f();
  c.prototype.__super = s.prototype; //オーバーライド用に保持
  c.prototype.constructor = c;
  ...
}
Collection = extend(Array, function() {
  if (arguments.length == 1 && typeof n == "number") {
     return;
  }
  for (var i = 0; i < arguments.length; i++) {
    this.push(arguments[i]);
  }
  Collection.prototype.join = function(separator) { //オーバーライド
      return this.__super.join.apply(this, arguments);
  }
});

foo = new Collection (1,2,3);
foo.push(4);
foo.push(5);

実際の実行結果は以下のとおり

本文の最初で「ほぼ」旨くいくとお茶を濁している原因がコンストラクターの部分でプリミティブなオブジェクトの
コンストラクターを継承先から呼び出しても期待通りの振る舞いをしてくれません。自作のクラスを継承した場合は
this.__super.constructor.aply(this, arguments);とすれば旨くいくのですが・・・

そこで今回は強引に渡された引数を自前でpushしています。

それからもう一つ、直接要素を指定した場合にlengthが正しく反映されません。

var c = new Collection(1,2,3);
c[3] = 4;
alert(c.length); //期待値は4

最後にie7でも上記２点以外を対応される方法（力業）を示します。

function extend(s, c) {
  function f() {};
  if (s == Array) {
      var a = new s;
      f.prototype.constrctor = s;
      f.prototype.concat = a.concat;
      f.prototype.join = a.join;
      f.prototype.length = a.concat;
      f.prototype.pop = a.pop;
      f.prototype.push = a.push;
      f.prototype.reverse = a.reverse;
      f.prototype.shift = a.shift;
      f.prototype.slice = a.slice;
      f.prototype.sort = a.sort;
      f.prototype.splice = a.splice;
      f.prototype.unshift = a.unshift;
  } else {
      f.prototype = s.prototype;
  }
  c.prototype = new f();
  c.prototype.__super = s.prototype; //オーバーライド用に保持
  c.prototype.constructor = c;
  ...
}

前提はこれくらいでしょうか

1. オーバーライド時に継承元の関数が呼び出せる
2. 多階層の継承が出来る
3. C++でのvirtualな呼び出しが出来る

C++やC#をずっと使ってきた自分にとってはプロトタイプチェーンだけではVB6のClassのような残念感があります。
やはりポリモーフィズムやオーバーライドが出来ないと逆に不便です。
色々な継承パターンを調べてみましたが、extendパターンが自分向きのようです。

まずは単純なextend関数

function extend(s, c)
{
    function f(){};
    f.prototype = s.prototype;
    c.prototype = new f();
    c.prototype.__super = s.prototype;
    c.prototype.__super.constructor = s;
    c.prototype.constructor = c;
    return c;
};

いきなり余談ですが、JavaScriptではインスタンスも拡張できるので以下のような書き方が出来れば、メタクラスの概念も導入できそうですが、
私は使わないので考慮しないことにします。

MetaClass = function() {}
Class = new MetaClass() {}  //クラスはメタクラスのインスタンス
SubClass = extend(Class, function() {
});

閑話休題。
次にコンストラクターをC#やVB.Netの雰囲気で呼び出せるようにbaseメソッドを追加します。

function extend(s, c)
{
    function f(){};
    f.prototype = s.prototype;
    c.prototype = new f();
    c.prototype.__super = s.prototype;
    c.prototype.__super.constructor = s;
    c.prototype.constructor = c;
    c.prototype.base = s;
    return c;
};

と、これをやると多層継承で嵌ります。

a = function() {}
b = extend(a, function() {
  this.base(); //ここのthisがクラスbを指し続けてしまう。
});
c = extend(b, function() {
  this.base();
});
var foo = new c();

なのでbaseを関数で実装する

function extend(s, c)
{
    function f(){};
    f.prototype = s.prototype;
    c.prototype = new f();
    c.prototype.__super = s.prototype;
    c.prototype.__super.constructor = s;
    c.prototype.constructor = c;
    c.prototype.base = function() {
      var ob = this.base;
      this.base = s.prototype.base;
      s.apply(this, arguments);
      if( this.constructor == c) {//baseを一回しか呼べないように削除しておく
          delete this.base;
      } else {
          this.base = ob;
      }
    }
    return c;
};

次はメソッドのオーバーライドです。以下のやり方では、bでオーバーライドしたbarが期待通り呼び出されません。

a = function() {};
a.prototype.foo = function() { 
  this.bar();　//bのbarを読んでくれません。
}
a.prototype.bar = function() {
  this._bar = "bar";
}

b = extend(a, function() {
  this.base();
});
b.prototype.foo = function() {
  this.__super.foo();
}
b.prototype.bar = function() {
　this.__super.bar();
  this._bar += "b";
}

var hoge = new b();
hoge.foo();

これは、this.__super.foo();をthis.__super.foo.apply(this,arguments);とすることで解決します。

ところが、この記述はbaseと同様に多層継承での問題をはらんでいます。

結局、ここについては専用の関数を提供することにしました。

__super__ = function(me, m, a) {
    a = a || [];
    var b = me.__super;
    var r,s;
    if (b && b[f] == me[f]) {
        for (s = me.__super.__super; s && s[f] == me[f]; s = s.__super) {
            ;
        }
    } else {
        s = b;
    }
    if (s == null) {
        throw new Error("__dqsuper__: 循環呼び出しか、継承されていないオブジェクトから呼び出されました。");
    }
    me.__super = s.__super;
    r = (typeof f == "string") ? s[f].apply(me, a) : f.apply(me, a);
    me.__super = b;

    return r;
}

一応完成形

function extend(s, c, m) {
    function f(){};
    f.prototype = s.prototype;
    c.prototype = new f();
    c.prototype.__super = s.prototype;
    c.prototype.__super.constructor = s;
    c.prototype.constructor = c;
    c.prototype.base = function() {
      var ob = this.base;
      this.base = s.prototype.base;
      s.apply(this, arguments);
      if( this.constructor == c) { 
          delete this.base;
      } else {
          this.base = ob;
      }
    }
    //属性を拡張
    for (var n in m) {
        c.prototype[n] = m[n];
    }
    return c;
}

デモ
JavaScript Arrayの継承について