JavaScript面向对象的继承应用

面向对象语言的三大特征:继承、封装、多态

<!DOCTYPE html>
<html>
<head>
    <title>Extend-OPP</title>
</head>
<script type="text/javascript">
    function Person(name,sex){
        this.name=name;
        this.sex=sex;
    }
    Person.prototype.showName = function() {
    alert(this.name);
    };
    Person.prototype.showSex=function(){
        alert(this.sex);
    };
    var oP1=new Person(‘blue‘,‘man‘);
    // oP1.showSex();
    function Worker(name,sex,job){
        //构造函数伪装 Call the parent‘s construtor
        Person.call(this,name,sex);
        this.job=job;
    }
    // 原型链 Use the prototype to extend the parent‘s function
    //Worker.prototype=Person.prototype;
    for (var i in Person.prototype){
        Worker.prototype[i]=Person.prototype[i];
    }
    Worker.prototype.showJob=function(){
        alert(this.job);
    };
    var oW1=new Worker(‘Jack‘,‘man‘,‘Designer‘);
    oW1.showJob();
</script>
<body>

</body>
</html>

使用面向对象继承的实例:

index.html

<!DOCTYPE html>
<html>
<head>
    <title>drag Div</title>
    <style type="text/css">
        #div1{width: 100px;height: 100px;background: red;position: absolute;}
        #div2{width: 100px;height: 100px;background: yellow;position: absolute;}
    </style>
    <script src="drag.js"></script>
    <script src="Limitdrag.js"></script>
    <script type="text/javascript">
    window.onload=function(){
        new Drag(‘div1‘);
        new LimitDrag(‘div2‘);
    }
    </script>
</head>
<body>
    <div id="div1"></div>
    <div id="div2"></div>
</body>
</html>

darg.js

        function Drag(id){
            var _this=this;
            this.disX=0;
            this.dixY=0;
            this.oDiv=document.getElementById(id);
            this.oDiv.onmousedown=function(ev)
            {
                _this.fnDown(ev);
                return false;
            };

    }
Drag.prototype.fnDown=function(ev){
                var _this=this;
                var oEvent=ev||event;
                this.disX=oEvent.clientX-this.oDiv.offsetLeft;
                this.disY=oEvent.clientY-this.oDiv.offsetTop;
                document.onmousemove=function(ev){
                    _this.fnMove(ev);
                };
            document.onmouseup=function(){
                _this.fnUp();
            };
        };
Drag.prototype.fnMove=function(ev){
                var oEvent=ev||event;
                this.oDiv.style.left=oEvent.clientX-this.disX+‘px‘;
                this.oDiv.style.top=oEvent.clientY-this.disY+‘px‘;
                // this.oDiv.style.left=l+‘px‘;
                // this.oDiv.style.top=t+‘px‘;
            };
Drag.prototype.fnUp=function(){
                document.onmousemove=null;
                document.onmouseup=null;
            };

Limitdrag.js

function LimitDrag(id){
    Drag.call(this,id);
}
for(var i in Drag.prototype){
    LimitDrag.prototype[i]=Drag.prototype[i];
}
LimitDrag.prototype.fnMove=function(ev){
                var oEvent=ev||event;
                var l=oEvent.clientX-this.disX;
                var t=oEvent.clientY-this.disY;

                    if (l<0)
                 {l=0;}
                else if(l>document.documentElement.clientWidth-this.oDiv.offsetWidth){
                    l=document.documentElement.clientWidth-this.oDiv.offsetWidth;
                }
                    if (t<0)
                 {t=0;}
                else if(t>document.documentElement.clientHeight-this.oDiv.offsetHeight){
                    t=document.documentElement.clientHeight-this.oDiv.offsetHeight;
                }
                this.oDiv.style.left=l+‘px‘;
                this.oDiv.style.top=t+‘px‘;
            };

原文地址:https://www.cnblogs.com/cheryshi/p/8494623.html

时间: 2024-11-05 11:57:20

JavaScript面向对象的继承应用的相关文章

javascript面向对象程序设计——继承初步(by vczero)

上一篇说了javascript的封装,没有刻意去说javascript的“共有函数”.“私有函数”,因为个人觉得这只是作用域的问题,我们不能刻意的模仿强类型语言(C++/JAVA)而去编写代码.尊重每一门语言的特性才是最为重要的. 一.基于prototype原型的继承 1 var Person = function(name, age){ 2 this.name = name; 3 this.age = age; 4 } 5 6 Person.prototype = { 7 addUser: f

javascript 面向对象和继承

我相信,当你读完这篇100%原创文章时,javascript 面向对象和继承轻松拿下不再是问题. 统一的html和css <div id="app"></div> #app{ position: relative; width:500px; height:500px; background: #ccc; } 第一,面向对象是什么,为什么需要它. 这里有另外一个词,叫面向过程.先理解这个,比如我们需要用js写出一个div自由降落的效果.我们自然而然是手动创建一个d

JavaScript面向对象原型继承

<script type="text/javascript"> //原型链继承 function shape() { this.name="shape"; this.showname=function(){ console.log(this.name); } } function shape_Two() { this.name='shape_Two' } function Triangle(side,height) { this.name="T

javascript面向对象:继承、多态

继承 js中同样可以实现类的继承这一面向对象特性,继承父类中的所有成员(变量和属性),同时可扩展自己的成员,下面介绍几种js中实现继承的方式: 1,对象模仿:通过动态的改变 this 指针的指向,实现对父类成员的重复定义,如下: function ClassA(paramColor) { this.color = paramColor; this.sayColor = function() { alert(this.color); } } function ClassB(paramColor,

JavaScript面向对象之类的继承

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/1999/xhtml"> <head> <meta http-equiv="Content-

Javascript面向对象特性实现封装、继承、接口详细案例——进级高手篇

Javascript面向对象特性实现(封装.继承.接口) Javascript作为弱类型语言,和Java.php等服务端脚本语言相比,拥有极强的灵活性.对于小型的web需求,在编写javascript时,可以选择面向过程的方式编程,显得高效:但在实际工作中,遇到的项目需求和框架较大的情况下,选择面向对象的方式编程显得尤其重要,Javascript原生语法中没有提供表述面向对象语言特性的关键字和语法(如extends.implement).为了实现这些面向对象的特性,需要额外编写一些代码,如下.

Javascript面向对象编程(二):构造函数的继承

这个系列的第一部分,主要介绍了如何"封装"数据和方法,以及如何从原型对象生成实例. 今天要介绍的是,对象之间的"继承"的五种方法. 比如,现在有一个"动物"对象的构造函数. function Animal(){ this.species = "动物"; } 还有一个"猫"对象的构造函数. function Cat(name,color){ this.name = name; this.color = col

《JavaScript》——面向对象之继承

继承是面向对象中一个比较核心的概念. 其他正统面向对象语言都会用两种方式实现继承:一个是接口实现,一个是继承.而 ECMAScript 只支持继承,不支持接口实现,而实现继承的方式依靠原型链完成.在JavaScript中的继承中,分了好几类继承,可以说是伴随着问题的出现,继承的方法也升级了,不光是原型链继承,还有组合继承.原型继承.寄生式继承.寄生组合继承等等.他们伴随着不同问题的出现而出现,下面我分别介绍一下这几种继承方式. 1.原型链式继承 <span style="font-fami

Javascript面向对象(封装、继承)

Javascript 面向对象编程(一):封装 作者:阮一峰 Javascript是一种基于对象(object-based)的语言,你遇到的所有东西几乎都是对象.但是,它又不是一种真正的面向对象编程(OOP)语言,因为它的语法中没有class(类). 那么,如果我们要把"属性"(property)和"方法"(method),封装成一个对象,甚至要从原型对象生成一个实例对象,我们应该怎么做呢? 一. 生成实例对象的原始模式 假定我们把猫看成一个对象,它有"名