Javascript基於物件三大特性（封裝性、繼承性、多型性）_javascript技巧
- WBOY原創
- 2016-05-16 15:22:091611瀏覽
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>
1、多態基本概念
多態是指一個引用(類型)在不同情況下的多種狀態。也可以理解成：多態是指透過指向父類別的引用，來呼叫在不同子類別中實作的方法。
案例：
<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 一個物件。
以上就是Javascript基於物件三大特性，希望對大家的學習有所幫助。
陳述：
本文內容由網友自願投稿，版權歸原作者所有。本站不承擔相應的法律責任。如發現涉嫌抄襲或侵權的內容，請聯絡admin@php.cn