javascript设计模式-继承

javascript继承分为两种:类式继承(原型链、extend函数)、原型式继承(对继承而来的成员的读和写的不对等性、clone函数)。

  1. 类式继承-->prototype继承:

     1     function Person(name){
     2         this.name = name;
     3     }
     4     Person.prototype.getName = function(){
     5         return this.name;
     6     }
     7
     8     //继承
     9     function Author(name,books){
    10         Person.call(this,name);
    11         this.books = books;
    12     }
    13     Author.prototype = new Person();
    14     Author.prototype.constructor = Author;
    15     Author.prototype.getBooks = function(){
    16         return this.books;
    17     }
    18
    19     var author = new Author("zap","javascript程序设计");
    20     console.log(author);
  2. 类式继承-->extend函数:

     1     function extend(subClass,superClass){
     2         var F = function(){};
     3         F.prototype = superClass.prototype;
     4         subClass.prototype = new F();
     5         subClass.prototype.constructor = subClass;
     6
     7         subClass.superClass = superClass.prototype;
     8         if(superClass.prototype.constructor == Object.prototype.constructor){
     9             superClass.prototype.constructor =  superClass;
    10         }
    11     }
    12
    13
    14     /*Class Person*/
    15
    16     function Person(name){
    17         this.name = name;
    18     }
    19     Person.prototype.getName = function(){
    20         return this.name;
    21     }
    22
    23     function Author(name,books){
    24         Author.superClass.constructor.call(this,name);
    25 //        Person.call(this,name);
    26         this.books = books;
    27     }
    28     extend(Author,Person);
    29     Author.prototype.getBooks = function(){
    30         return this.books;
    31     }
    32
    33     var author = new Author("zap","javascript程序设计");
    34     console.log(author);
    35     console.log(author.getName());
    36     console.log(author.getBooks());
  3. 原型式继承-->clone函数:(原型式继承更能节约内存)

     1     var Person  ={
     2         name:"zap",
     3         age:"26",
     4         toString:function(){
     5             console.log(this.name + "@" + this.age);
     6         }
     7     }
     8
     9     var author = clone(Person);
    10     author.name = "zap";
    11     author.toString();
    12
    13     function clone(object){
    14         function F(){}
    15         F.prototype = object;
    16         return new F;
    17     }

    附上以类式继承实现的就地编辑demo,原型式方式实现和类式继承方式相差无几,不在此列举。

      1 <!DOCTYPE html>
      2 <html>
      3     <head>
      4         <meta charset="UTF-8">
      5         <title>类式继承解决方案</title>
      6         <style type="text/css">
      7             #doc{width:500px; height:300px; border:1px solid #ccc; margin:10px auto;}
      8         </style>
      9     </head>
     10     <body>
     11         <div id="doc"></div>
     12     </body>
     13 </html>
     14 <script type="text/javascript">
     15
     16     function EditInPlaceField(id,parent,value){
     17         this.id = id;
     18         this.value = value || "default value";
     19         this.parentElement = parent;
     20
     21         this.createElements(this.id);
     22         this.attachEvents();
     23     }
     24
     25     EditInPlaceField.prototype = {
     26         createElements:function(id){
     27             this.createContainer();
     28             this.createShowPanel();
     29             this.createEnterPanel();
     30             this.createControlBtns();
     31             this.convertToText();
     32         },
     33          //创建容器
     34         createContainer:function(){
     35             this.containerElement = document.createElement("div");
     36             this.parentElement.appendChild(this.containerElement);
     37         },
     38         createShowPanel:function(){
     39             this.staticElement = document.createElement("span");
     40             this.containerElement.appendChild(this.staticElement);
     41             this.staticElement.innerHTML  = this.value;
     42         },
     43         createEnterPanel:function(){
     44             this.fieldElement = document.createElement("input");
     45             this.fieldElement.type = "text";
     46             this.fieldElement.value = this.value;
     47             this.containerElement.appendChild(this.fieldElement);
     48         },
     49         createControlBtns:function(){
     50             this.saveButton = document.createElement("input");
     51             this.saveButton.type = "button";
     52             this.saveButton.value = "Save";
     53             this.containerElement.appendChild(this.saveButton);
     54
     55
     56             this.cancelButton = document.createElement("input");
     57             this.cancelButton.type = "button";
     58             this.cancelButton.value = "Cancel";
     59             this.containerElement.appendChild(this.cancelButton);
     60         },
     61         attachEvents:function(){
     62             var that = this;
     63             addEvent(this.staticElement,"click",function(){that.convertToEditable();});
     64             addEvent(this.saveButton,"click",function(){that.save();});
     65             addEvent(this.cancelButton,"click",function(){that.cancel();});
     66         },
     67         convertToEditable:function(){
     68             this.staticElement.style.display = "none";
     69             this.fieldElement.style.display = "inline";
     70             this.saveButton.style.display = "inline";
     71             this.cancelButton.style.display = "inline";
     72
     73             this.setValue(this.value);
     74         },
     75         save:function(){
     76             this.value = this.getValue();
     77             var that = this;
     78             var callback = {
     79                 success:function(){
     80                     that.convertToText();
     81                 },
     82                 failure:function(){
     83                     alert("Error saving value.");
     84                 }
     85             };
     86
     87             ajaxRequest("get","save.php?id=",callback);
     88         },
     89         cancel:function(){
     90             this.convertToText();
     91         },
     92         convertToText:function(){
     93             this.fieldElement.style.display = "none";
     94             this.saveButton.style.display = "none";
     95             this.cancelButton.style.display = "none";
     96             this.staticElement.style.display = "inline";
     97
     98             this.setValue(this.value);
     99         },
    100         setValue:function(value){
    101             this.fieldElement.value = value;
    102             this.staticElement.innerHTML = value;
    103         },
    104         getValue:function(){
    105             return this.fieldElement.value;
    106         }
    107     }
    108
    109     //事件绑定
    110     function addEvent(element,type,fn){
    111         if(element.addEventListener){
    112             element.addEventListener(type,fn,false);
    113         }else if(element.attachEvent){
    114             element.attachEvent("on" + type,fn);
    115         }else{
    116             element["on" + type] = fn;
    117         }
    118     }
    119     //ajax请求
    120     function ajaxRequest(type,url,callback){
    121         callback.success();
    122     }
    123     //extend
    124     function extend(subClass,superClass){
    125         var F = function(){};
    126         F.prototype = superClass.prototype;
    127         subClass.prototype = new F();
    128         subClass.prototype.constructor = subClass;
    129
    130         subClass.superClass = superClass.prototype;
    131         if(superClass.prototype.constructor == Object.prototype.constructor){
    132             superClass.prototype.constructor =  superClass;
    133         }
    134     }
    135
    136     //子类
    137     function EditInPlaceArea(id,parent,value){
    138         EditInPlaceArea.superClass.constructor.call(this,id,parent,value);
    139     };
    140     extend(EditInPlaceArea,EditInPlaceField);
    141
    142     //override
    143     EditInPlaceArea.prototype.createShowPanel = function() {
    144         this.staticElement = document.createElement("p");
    145         this.containerElement.appendChild(this.staticElement);
    146         this.staticElement.innerHTML = this.value;
    147     }
    148
    149     EditInPlaceArea.prototype.createEnterPanel = function(){
    150         this.fieldElement =document.createElement("textarea");
    151         this.fieldElement.value = this.value;
    152         this.containerElement.appendChild(this.fieldElement);
    153     }
    154
    155     EditInPlaceArea.prototype.convertToEditable = function(){
    156         this.staticElement.style.display = "none";
    157         this.fieldElement.style.display = "block";
    158         this.saveButton.style.display = "inline";
    159         this.cancelButton.style.display = "inline";
    160
    161         this.setValue(this.value);
    162     }
    163
    164     EditInPlaceArea.prototype.convertToText = function(){
    165         this.fieldElement.style.display = "none";
    166         this.saveButton.style.display = "none";
    167         this.cancelButton.style.display = "none";
    168         this.staticElement.style.display = "block";
    169         this.setValue(this.value);
    170     }
    171
    172     var titleClassical = new EditInPlaceArea("titleClassical",document.getElementById("doc"),"title here");
    173
    174 </script>

时间: 2024-10-06 19:18:53

javascript设计模式-继承的相关文章

【Javascript设计模式】第一课 Javascript中的继承

在Javascript中每个类有三个部分:     1.第一部分是构造函数内,这是供实例化对象复制用的. 2.第二部分是构造函数外,通过点语法添加的,这是供类使用的,实例化对象是访问不到的. 3.第三部分是类的原型中,实例化对象可以通过其原型链间接访问到,也是为供所有实例化对象所共用的. 一. 子类的原型对象 --类式继承 类式继承是最常见最简单的继承模式,类式继承用一句话概括就是"父类实例指向子类原型" /** * 声明一个父类 * @constructor */ var Super

浅谈javascript继承【读javascript设计模式第四章节继承有感】

javascript继承,无任是类式继承,原型式继承还是渗元式继承都是通过不同方法去围绕着prototype转,简单分析下三种不同继承方法是如何围绕prototype转的 一:类似继承,先上关键代码 function extend(subClass,supClass){ var fn = function(){}; fn.prototype = supClass.prototype; subClass.prototype = new fn(); subClass.prototype.constr

javascript设计模式

javascript设计模式 阅读目录 什么是设计模式 单体模式: 工厂模式: 单例模式 观察者模式(发布订阅模式) 策略模式 模板模式 代理模式 外观模式 设计模式太多了,貌似有23种,其实我们在平时的工作中没有必要特意去用什么样的设计模式,或者你在不经意间就已经用了设计模式当中的一种.本文旨在总结平时相对来说用的比较多的设计模式. 回到顶部 什么是设计模式 百度百科: 设计模式(Design pattern)是一套被反复使用.多数人知晓的.经过分类编目的.代码设计经验的总结. 使用设计模式是

浅谈JavaScript的继承

我想我的JavaScript的基本语法基础掌握的差不多了,现在没时间,毕竟那么多考试等着我.等到寒假我就把犀牛书过一遍. 本来就有那么多考试,但是我还是忍不住写点JavaScript的代码.我认为我的基础差不多了,我就把那本<JavaScript设计模式>拿出来看,我之前是看不懂的. 然后我想我现在应该看得懂了吧.就特意找了继承这一章看一看. ——————————————————————我是厉害的分割线———————————————————————————————————————— 只能说勉强

Javascript设计模式系列三

继承,一个类或对象继承另一个类或对象的三种方法.类式继承.原型式继承.掺元类. 一.类式继承,原型链.Extend函数. <script type="text/javascript"> ////定义Person类 var Person = function (name) { this.name = name; }; Person.prototype.getName = function () { return this.name; }; ////原型链 function A

《JavaScript设计模式 张》整理

最近在研读另外一本关于设计模式的书<JavaScript设计模式>,这本书中描述了更多的设计模式. 一.创建型设计模式 包括简单工厂.工厂方法.抽象工厂.建造者.原型和单例模式. 1)简单工厂 又叫静态工厂方法,由一个工厂对象决定创建某一种产品对象类的实例. 两种实现方式,第一种是通过类实例化对象创建,第二种是创建一个新对象然后包装增强其属性和功能. demo代码. 2)工厂方法 通过对产品类的抽象使其创建业务主要负责用于创建多类产品的实例. 将工厂方法看作是一个实例化对象的工厂类. demo

javascript设计模式学习之一——javascript面向对象与java的区别

一.静态语言与动态语言面向对象之对比 封装: 1)封装数据:java中通过私有变量Private等实现,javascript中通过函数内的局部变量实现 2)封装实现:对象内部的变化对于外部是透明的,对象之间通过暴露的接口进行通信 3)封装类型:java中通过实现继承(抽象类)或者接口继承(接口)来想方设法实现对象类型的隐藏达到多态的效果,javascript中压根没有这个问题: 4)封装变化:这就是设计模式的目的,封装代码中变化的部分.设计模式分为三种:创建型模式目的在于封装创建对象的变化,结构

javascript设计模式实践之职责链--具有百叶窗切换图片效果的JQuery插件(三)

在上一篇<javascript设计模式实践之模板方法--具有百叶窗切换图片效果的JQuery插件(二)>里,通过采用模板方法模式完成了切换效果对象的构建编写. 接下来就是完成各效果对象的调用和联动. 切换要求:当前图片显示指定时间后执行切换效果并切换下一张图片,最后一个切换后从头开始. 按照要求一个效果对象完成后要执行下一个,最后一个完成后要从头开始, 看上去就是一个带状态通知的环形列表,类似于这样的特征,可以采用职责链模式来构建. 职责链就是由不同的功能处理构成的链表,每一个功能处理作为一个

【读书】JavaScript 设计模式与开发实践

2016.08.30 <JavaScript 设计模式与开发实践> 曾探 人民邮电出版社 2016年5月第1版 p13 找到变化的部分并封装之,以使得容易替换:而剩下的就是不变的部分. P49 函数柯里化(currying)的作用是多次收集参数,然后作为数组传给处理函数再一次执行. 其意义在于预处理--将预处理的流程放到一个函数里会更为清晰可控. P57 惰性加载函数 在函数内部重写引用函数的外部变量的引用,从而在第一次"调用"此变量后,此变量就指向新的正确的函数. p84