Javascript基于对象三大特征 -- 冒充对象
Javascript基于对象三大特征
基本概述
JavaScript基于对象的三大特征和C++,Java面向对象的三大特征一样,都是封装(encapsulation)、继承(inheritance )和多态(polymorphism )。只不过实现的方式不同,其基本概念是差不多的。其实除三大特征之外,还有一个常见的特征叫做抽象(abstract),这也就是我们在一些书上有时候会看到面向对象四大特征的原因了。
封装性
封装就是把抽象出来的数据和对数据的操作封装在一起,数据被保护在内部,程序的其它部分只有通过被授权的操作(成员方法),才能对数据进行操作。
案例:
- <html>
- <head>
- <script type="text/javascript">
- function Person(name, agei, sal){
- // 公开
- this.name = name;
- // 私有
- var age = agei;
- var salary = sal;
- }
- var p1 = new Person('zs', 20, 10000);
- window.alert(p1.name + p1.age);
- </script>
- </head>
- <body>
- </body>
- </html>
PS:JS封装只有两种状态,一种是公开的,一种是私有的。
通过构造函数添加成员方法和通过原型法添加成员方法的区别
1、通过原型法分配的函数是所有对象共享的.
2、通过原型法分配的属性是独立.(如果你不修改属性,他们是共享)
3、建议,如果我们希望所有的对象使用同一一个函数,最好使用原型法添加函数,这样比较节省内存.
案例:
- function Person(){
- this.name="zs";
- var age=20;
- this.abc=function(){
- window.alert("abc");
- }
- function abc2(){
- window.alert("abc");
- }
- }
- Person.prototype.fun1=function(){
- window.alert(this.name);//ok
- //window.alert(age);//no ok
- //abc2();//no ok
- this.abc();//ok
- }
- var p1=new Person();
- p1.fun1();
特别强调:我们前面学习的通过prototype给所有的对象添加方法,但是这种方式不能去访问类的私有变量和方法。
继承性
继承可以解决代码复用,让编程更加靠近人类思维。当多个类存在相同的属性(变量)和方法时,可以从这些类中抽象出父类,在父类中定义这些相同的属性和方法,所有的子类不需要重新定义这些属性和方法,只需要通过继承父类中的属性和方法。
JS中实现继承的方式
1、对象冒充
案例:
- <html>
- <head>
- <script type="text/javascript">
- function Stu(name, age){
- this.name = name;
- this.age = age;
- this.show = function(){
- window.alert(this.name + " " + this.age);
- }
- }
- function MidStu(name, age) {
- this.stu = Stu;
- // 通过对象冒充来实现继承的
- // 对象冒充的意思就是获取那个类的所有成员,因为js是谁调用那个成员就是谁的,这样MidStu就有了Stu的成员了
- this.stu(name, age);
- this.payFee = function(){
- window.alert("缴费" + money * 0.8);
- }
- }
- function Pupil(name, age) {
- this.stu = Stu;
- // 通过对象冒充来实现继承的
- this.stu(name, age);
- this.payFee = function(){
- window.alert("缴费" + money * 0.5);
- }
- }
- var midStu = new MidStu("zs", 13);
- midStu.show();
- var pupil = new Pupil("ls", 10);
- pupil.show();
- </script>
- </head>
- <body>
- </body>
- </html>
2、通过call或者apply实现
案例:
- <html>
- <head>
- <script type="text/javascript">
- //1. 把子类中共有的属性和方法抽取出,定义一个父类Stu
- function Stu(name,age){
- // window.alert("确实被调用.");
- this.name=name;
- this.age=age;
- this.show=function(){
- window.alert(this.name+"年龄是="+this.age);
- }
- }
- //2.通过对象冒充来继承父类的属性的方法
- function MidStu(name,age){
- //这里这样理解: 通过call修改了Stu构造函数的this指向,
- //让它指向了调用者本身.
- Stu.call(this,name,age);
- //如果用apply实现,则可以
- //Stu.apply(this,[name,age]); //说明传入的参数是 数组方式
- //可以写MidStu自己的方法.
- this.pay=function(fee){
- window.alert("你的学费是"+fee*0.8);
- }
- }
- function Pupil(name,age){
- Stu.call(this,name,age);//当我们创建Pupil对象实例,Stu的构造函数会被执行,当执行后,我们Pupil对象就获取从 Stu封装的属性和方法
- //可以写Pupil自己的方法.
- this.pay=function(fee){
- window.alert("你的学费是"+fee*0.5);
- }
- }
- //测试
- var midstu=new MidStu("zs",15);
- var pupil=new Pupil("ls",12);
- midstu.show();
- midstu.pay(100);
- pupil.show();
- pupil.pay(100);
- </script>
- </html>
小结:
1、JS对象可以通过对象冒充,实现多重继承
2、Object类是所有Js类的基类
多态性
JS的函数重载
这个是多态的基础,在之前的Javascript入门已经说过了,JS函数不支持多态,但是事实上JS函数是无态的,支持任意长度,类型的参数列表。如果同时定义了多个同名函数,则以最后一个函数为准。
案例:
- <html>
- <head>
- <script type="text/javascript">
- //*****************说明js不支持重载*****
- /*function Person(){
- this.test1=function (a,b){
- window.alert('function (a,b)');
- }
- this.test1=function (a){
- window.alert('function (a)');
- }
- }
- var p1=new Person();
- //js中不支持重载.
- //但是这不会报错,js会默认是最后同名一个函数,可以看做是后面的把前面的覆盖了。
- p1.test1("a","b");
- p1.test1("a");*/
- //js怎么实现重载.通过判断参数的个数来实现重载
- function Person(){
- this.test1=function (){
- if(arguments.length==1){
- this.show1(arguments[0]);
- }else if(arguments.length==2){
- this.show2(arguments[0],arguments[1]);
- }else if(arguments.length==3){
- this.show3(arguments[0],arguments[1],arguments[2]);
- }
- }
- this.show1=function(a){
- window.alert("show1()被调用"+a);
- }
- this.show2=function(a,b){
- window.alert("show2()被调用"+"--"+a+"--"+b);
- }
- function show3(a,b,c){
- window.alert("show3()被调用");
- }
- }
- var p1=new Person();
- //js中不支持重载.
- p1.test1("a","b");
- p1.test1("a");
- </script>
- </html>
多态基本概念
多态是指一个引用(类型)在不同情况下的多种状态。也可以理解成:多态是指通过指向父类的引用,来调用在不同子类中实现的方法。
案例:
- <script type="text/javascript">
- // Master类
- function Master(name){
- this.nam=name;
- //方法[给动物喂食物]
- }
- //原型法添加成员函数
- Master.prototype.feed=function (animal,food){
- window.alert("给"+animal.name+" 喂"+ food.name);
- }
- function Food(name){
- this.name=name;
- }
- //鱼类
- function Fish(name){
- this.food=Food;
- this.food(name);
- }
- //骨头
- function Bone(name){
- this.food=Food;
- this.food(name);
- }
- function Peach(name){
- this.food=Food;
- this.food(name);
- }
- //动物类
- function Animal(name){
- this.name=name;
- }
- //猫猫
- function Cat(name){
- this.animal=Animal;
- this.animal(name);
- }
- //狗狗
- function Dog(name){
- this.animal=Animal;
- this.animal(name);
- }
- //猴子
- function Monkey(name){
- this.animal=Animal;
- this.animal(name);
- }
- var cat=new Cat("猫");
- var fish=new Fish("鱼");
- var dog=new Dog("狗");
- var bone=new Bone("骨头");
- var monkey=new Monkey("猴");
- var peach=new Peach("桃");
- //创建一个主人
- var master=new Master("zs");
- master.feed(dog,bone);
- master.feed(cat,fish);
- master.feed(monkey,peach);
- </script>
总结:
多态利于代码的维护和扩展,当我们需要使用同一类树上的对象时,只需要传入不同的参数就行了,而不需要再new 一个对象。
----------参考《韩顺平.轻松搞定网页设计(html+css+js)》
Javascript基于对象三大特征 -- 冒充对象的更多相关文章
- python----面对对象三大特征2
多态 什么是多态?多态指的是一类事物有多种形态,例如一个动物类,狗和猫都通过继承动物类来得来,这样我们可以将狗.猫称作动物类的另一种形态. 在java中也存在多态,java中的多态是用来解决在一个函数 ...
- Java--面向对象三大特征-->封装、继承、多态
简介 在面向过程当中只有存在封装(对功能的封装 例如c语言中的函数),而在面向对象中才存在这三大特性. 继承 -->inheritance 1.子类可以从父类继承属性和方法(除去父类私有化的方法 ...
- Java-面向对象三大特征、设计规则
1)封装: 1.1)类:封装的是对象的属性和行为 1.2)方法:封装的是具体的业务逻辑实现 1.3)访问控制修饰符:封装的是访问的权限 2)继承: 2.1)作用:代码的复用 2.2)父类/基类:共有的 ...
- JS面向(基于)对象编程--三大特征
抽象 在讲解面向对象编程的三大特征前,我们先了解什么叫抽象,在定义一个类时候,实际上就是把一类事物的共有的属性和行为提取出来,形成一个物理模型(模板).这种研究问题的方法称为抽象. 封装 什么是封装? ...
- JavaScript基于对象编程
js面向对象特征介绍 javascript是一种面向(基于)对象的动态脚本语言,是一种基于对象(Object)和事件驱动(EventDirven)并具有安全性能的脚本语言.它具有面向对象语言所特有的各 ...
- 自学Python5.5-面向对象三大基本特征_继承
自学Python之路-Python基础+模块+面向对象自学Python之路-Python网络编程自学Python之路-Python并发编程+数据库+前端自学Python之路-django 自学Pyth ...
- python---面对对象的三大特征
一.三大特征 面对对象的三大特征:继承.多态和封装,继承在面向对象类的创建中非常常见. 1.继承 为什么会有继承,当我们要创建一个新类的时候,发现他有很多属性或者反法都和我们另一个类的方法相同,这时我 ...
- Python31之类和对象1(三大特征:多封继——多疯子)
一.对象: Python即是面向对象的编程也是面向过程的编程语言,其内部可谓是无处不对象,我们所熟知的列表,字符串等工厂函数本质上都是对象.对象其实是对属性和方法的封装. 属性是对象的静态特征 方法是 ...
- 自学Python5.7-面向对象三大基本特征_封装
自学Python之路-Python基础+模块+面向对象自学Python之路-Python网络编程自学Python之路-Python并发编程+数据库+前端自学Python之路-django 自学Pyth ...
随机推荐
- HDU 4745 Two Rabbits(最长回文子序列)(2013 ACM/ICPC Asia Regional Hangzhou Online)
Description Long long ago, there lived two rabbits Tom and Jerry in the forest. On a sunny afternoon ...
- VirtualBox上安装ubuntu
当安装完成,重启后,在启动界面出现Please remove the installation medium,then press ENTER.问题? 解决方法:在VirtualBox里面通过iso文 ...
- ExtJS新手学习中常见问题
1.常常出现运行之后不出现应该出现的效果. 这种情况一般是引用ExtJS路径不正确,要确保路径正确. 示例: <!DOCTYPE html> <html lang="en& ...
- 【bzoj2325】[ZJOI2011]道馆之战 树链剖分+线段树区间合并
题目描述 给定一棵树,每个节点有上下两个格子,每个格子的状态为能走或不能走.m次操作,每次修改一个节点的状态,或询问:把一条路径上的所有格子拼起来形成一个宽度为2的长方形,从起点端两个格子的任意一个开 ...
- 【bzoj4976】宝石镶嵌 乱搞+dp
题目描述 从$n$个数中选出$n-k$个,使得它们的二进制或(or)最大.输出这个值. 输入 第一行包含两个正整数$n,k(2\le n\le 100000,1\le k\le 100,k<n) ...
- IE提示是否只查看安全传送的网页内容
IE选项-->安全-->点上面那个地球internet-->点下面那个 自定义级别-->找到“其他”-->显示混合内容,改为启用,重启打开下IE,就可以了
- POJ 3415 后缀数组+单调栈
题目大意: 给定A,B两种字符串,问他们当中的长度大于k的公共子串的个数有多少个 这道题目本身理解不难,将两个字符串合并后求出它的后缀数组 然后利用后缀数组求解答案 这里一开始看题解说要用栈的思想,觉 ...
- Tourists——圆方树
CF487E Tourists 一般图,带修求所有简单路径代价. 简单路径,不能经过同一个点两次,那么每个V-DCC出去就不能再回来了. 所以可以圆方树,然后方点维护一下V-DCC内的最小值. 那么, ...
- [学习笔记]可持久化数据结构——数组、并查集、平衡树、Trie树
可持久化:支持查询历史版本和在历史版本上修改 可持久化数组 主席树做即可. [模板]可持久化数组(可持久化线段树/平衡树) 可持久化并查集 可持久化并查集 主席树做即可. 要按秩合并.(路径压缩每次建 ...
- vector 基础
http://classfoo.com/ccby/article/jnevK Vector的存储空间是连续的,list不是连续存储的 vector初始化 vector<int>v; //不 ...