1<SCRIPT LANGUAGE="JavaScript">
 2  <!--
 3        function dwn(s)
 4        {
 5                document.write(s+'<br/>');
 6        }
 7
 8        //定义一个Collection类型
 9        function Collection(size)
10        {
11                this.size = function(){return size};  //公有方法，可以被继承
12        }
13
14        //定义一个_Collection类型
15        function _Collection(_size)
16        {
17                this._size = function(){return _size};  //公有方法，可以被继承
18        }
19
20        Collection.prototype.isEmpty = function()  //静态方法，不能被继承
21        {
22                return this.size() == 0;
23        }
24
25        //定义一个ArrayList类型，它“继承”Colleciton类型
26        function ArrayList()
27        {
28                var m_elements = [];  //私有成员，不能被继承
29                m_elements = Array.apply(m_elements,arguments);
30
31                //ArrayList类型继承Colleciton
32                this.base = Collection;
33                this.base.call(this,m_elements.length);
34
35                this.base = _Collection;                   //可以实现多态继承
36                this.base.call(this,m_elements.length);    
37
38                this.add = function()
39                {
40                        return m_elements.push.apply(m_elements,arguments);        
41                }
42
43                this.toArray = function()
44                {
45                        return m_elements;
46                }
47        }
48
49        ArrayList.prototype.toString = function()
50        {
51                return this.toArray().toString();
52        }
53
54        //定义一个SortedList类型，它继承ArrayList类型
55        function SortedList()
56        {
57                //SortedList类型继承ArrayList
58                this.base = ArrayList;
59                this.base.apply(this,arguments);
60
61                this.sort = function()
62                {
63                        var arr = this.toArray();
64                        arr.sort.apply(arr,arguments);
65                }
66        }
67
68        //构造一个ArrayList
69        var a = new ArrayList(1,2,3);
70        dwn(a);          //1,2,3
71        dwn(a.size());   //3 a从Collection继承了size()方法
72        dwn(a.isEmpty);  //undefined 但是a没有继承到isEmpty()方法
73
74        dwn(a._size());  //3 可以实现多态继承
75
76        //构造一个SortedList
77        var b = new SortedList(3,1,2);
78        dwn(b.toArray());
79        b.add(4,0);    //b 从ArrayList继承了add()方法
80        dwn(b.toArray());  //b从ArrayList继承了toArray()方法
81        b.sort();      //b自己实现sort()方法
82        dwn(b.toArray());
83        dwn(b);
84        dwn(b.size());   //b从Collection继承了size()方法
85  //-->
86  </SCRIPT>

 1  <SCRIPT LANGUAGE="JavaScript">
 2  <!--
 3        function dwn(s)
 4        {
 5                document.write(s+"<br/>");
 6        }
 7
 8        function Point(dimension)  //定义一个Point类
 9        {
10                this.dimension = dimension;
11        }
12
13        Point.prototype.distance = function() //静态方法，可以被继承
14        {
15                return this.dimension*2;
16        }
17
18        function Point2D(x,y)    //定义一个Point2D类
19        {
20                this.x = x;
21                this.y = y;
22        }
23
24        Point2D.prototype = new Point(2);   //运行“原型继承法”使Point2D继承Point
25
26        function Point3D(x,y,z)   //定义Point3D类
27        {
28                this.x = x;
29                this.y = y;
30                this.z = z;
31        }
32
33        Point3D.prototype = new Point(3);   //Point3D继承Point类
34
35        var p2 = new Point2D(1,2);  //构造一个Point2D对象
36
37        var p3 = new Point3D(1,2,3); //构造一个Point3D对象
38
39        dwn(p2.dimension);            //2
40        dwn(p3.dimension);            //3
41        dwn(p2.distance());           //4 可以继承静态方法
42        dwn(p3.distance());           //6 可以继承静态方法
43
44        dwn(p2 instanceof Point2D);   //p2是Point2D对象
45        dwn(p2 instanceof Point);     //Point2D继承Point,p2是Point对象
46
47        dwn(p3 instanceof Point3D);   //p3是Point3D对象
48        dwn(p3 instanceof Point);     //Point3D继承Point,p3是Point对象
49
50  //-->
51  </SCRIPT>

 1  <SCRIPT LANGUAGE="JavaScript">
 2  <!--
 3        function MyDate()
 4        {
 5                this.base = Date;
 6                this.base.apply(this,arguments);
 7        }
 8
 9        var date = new MyDate();
10        alert(date.toGMTSring());   //对象不支持此方法或属性
11        //核心对象（Date）的某些方法不能被构造继承，原因是核心对象并不像我们自定义的一般对象那样在构造函数里进行赋值或初始化操作。
12  //--> 

 1  <SCRIPT LANGUAGE="JavaScript">
 2  <!--
 3        function MyDate()
 4        {
 5
 6        }
 7        MyDate.prototype = new Date();
 8        var date = new MyDate();
 9        alert(date.toGMTSring());    //'[object]不是日期对象'
10  //-->
11  </SCRIPT>

 1  <SCRIPT LANGUAGE="JavaScript">
 2  <!--
 3        function dwn(s)
 4        {
 5                document.write(s+'<br/>');
 6        }
 7        function MyDate()
 8        {
 9                var instance = new Date();   //instance是一个新创建的日期对象
10                instance.printDate = function()  //对日期对象instance扩展printDate()方法
11                {
12                        dwn(instance.toLocaleString());
13                }
14                return instance;   //将instance作为构造函数的返回值返回
15        }
16
17        var date = new MyDate();
18        dwn(date.toGMTString());
19        date.printDate();    
20        dwn(date instanceof MyDate);  //false
21        dwn(date instanceof Date);    //true
22        //对象的构造函数将会是实际构造的对象的构造函数（new Date()），而不是类型本身的构造函数（new MyDate()）
23  //-->
24  </SCRIPT>

 1  <script language="JavaScript">
 2        function Point(dimension)
 3        {
 4                this.dimension = dimension;
 5        }
 6
 7        var Point2D = function(x,y)
 8        {
 9                this.x = x;
10                this.y = y;
11        }
12
13    Point2D.extend = function()
14        {
15            var p = new Point(2);
16            for(var each in p)   //将对象的属性进行一对一的复制。
17            {
18                 //this[each] = p[each];
19                 this.prototype[each] = p[each];
20            }
21        }
22    Point2D.extend();
23        //alert(Point2D.dimension);
24        alert(Point2D.prototype.dimension);
25  </script>