1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
<%@ page language= "java"  import= "java.util.*"  pageEncoding= "UTF-8" %>
<%
String path = request.getContextPath();
String basePath = request.getScheme()+ "://" +request.getServerName()+ ":" +request.getServerPort()+path+ "/" ;
%>
 
<!DOCTYPE HTML PUBLIC  "-//W3C//DTD HTML 4.01 Transitional//EN" >
<html>
   <head>
     <base href= "<%=basePath%>" >
     
     <title>My JSP  'oop7.jsp'  starting page</title>
     
     <meta http-equiv= "pragma"  content= "no-cache" >
     <meta http-equiv= "cache-control"  content= "no-cache" >
     <meta http-equiv= "expires"  content= "0" >    
     <meta http-equiv= "keywords"  content= "keyword1,keyword2,keyword3" >
     <meta http-equiv= "description"  content= "This is my page" >
     <!--
     <link rel= "stylesheet"  type= "text/css"  href= "styles.css" >
     -->
     <script type= "text/javascript" >
         //实现只继承父类的原型对象
         function  extend(Sub,Sup){
             //1.用一个空函数进行中转
             //穿件一个空函数，目的：中转
             var  F= new  Function();
             F.prototype=Sup.prototype;       //实现空函数的原型对象和超类的原型对象转换
             Sub.prototype= new  F();           //原型继承
             Sub.prototype.constructor=Sub;   //还原子类的构造器
             //保存父类的原型对象     1.方便解耦   2.可以方便获得分类的原型对象
             Sub.superClass=Sup.prototype;         //自定义一个子类的静态属性，接收父类的原型对象
             if (Sup.prototype.constructor==Object.prototype.constructor){
                 Sup.prototype.constructor=Sup;    //手动还原父类原型对象的构造器
             }
         }
         
         
         
         
         
         
         
         
         
         //混合继承：原型继承+构造函数继承
         function  Person(name,age){
             this .name=name;
             this .age=age;
             
         }
         
         Person.prototype={
             constructor:Person,
             sayName: function (){
                 alert( this .name);
             }
         }
         
         function  Boy(name,age,sex){
             Boy.superClass.constructor.call( this ,name,age);           //绑定父类的模板函数，借用构造，支复制了父类的模板
             this .sex=sex;
         }
         
         //Boy.prototype=new Person();    //既继承了父类的模板，又继承了父类的原型，但由于不习惯于在new Person时传入参数，所以会再使用call函数继承模板
         extend(Boy,Person);
         //给子类加上一个父类的覆盖方法
         Boy.prototype.sayName= function (){
             alert( '子类复写方法' );
         }
         var  b= new  Boy( '张三' ,23, '男' );
         alert(b.sex);
         b.sayName();
         Boy.superClass.sayName.call(b);      //调用父类的同名函数
         
         //3件事
         //混合继承缺点：继承了两次父类的模板，一次父类的原型对象
         
         
         
         //2集成一次父类的模板，一次父类的原型对象
         //只继承一遍父类的模板      自定义方法实现只继承一遍父类的模板extend方法
         
         
     </script>
   </head>
   
   <body>
     This is my JSP page. <br>
   </body>
</html>