javascript学习总结三 OOP(构造、属性、多态、继承)

来源:互联网 发布:手机淘宝如何发链接 编辑:程序博客网 时间:2024/03/29 16:18

javascript 构造方式:
//1. 工厂方法,使用newObject方法创建对象并添加相关属性
//2. 利用构造函数来定义类
//3. 使用prototype
//4. 构造函数以及原型混合方式
//5. 动态原型方式

 

//1.工厂方法,使用new Object方法创建对象并添加相关属性
//工厂生产产品,就是new Object来生产对象
//Object是所有类的基类
//Object可以派生多个不明确类名的类,造成该方法所动态生成的类是无法重用的
var tmpPerson = new Object();
tmpPerson.name = "zhangSan";
tmpPerson.age = 25;
tmpPerson.feeling = 80;
tmpPerson.money = 90;
tmpPerson.sayHello = function(){
document.writeSelf("My name is " + tmpPerson.name + ",my age is " + tmpPerson.age );
}
tmpPerson.sayHello();
//constructor:构造函数
//利用该方法所声明的类,依然类名还是Object
document.writeSelf(tmpPerson.constructor);
//prototype: 原型对象,静态属性,要用类去访问
document.writeSelf(tmpPerson.prototype);
*/
/*
//3.使用prototype,通过类名来动态添加到原型对象区域
function Person(){
    this.name = "LiSi";
}
Person.prototype.age = 15;
var tmpPerson = new Person();
tmpPerson.sex = "man";
var tmpPersonTwo = new Person();
//用key作为临时变量,依次遍历tmpPerson的各个成员,包括属性和方法
document.writeObject(tmpPerson);
document.writeObject(tmpPersonTwo);
//document.writeSelf(tmpPerson.age);
Object.prototype.age = 15;
var tmpPersonThree = new Object();
document.writeObject(tmpPersonThree);*/

/*//5.动态原型方式
var tmpPerson = {
                name:"LiSi",
                age:15,
                sayHello:function(){document.writeSelf("Hello");}
                };
document.writeObject(tmpPerson);*/

//1.5类似,比较灵活,每次定义对象都是全新的,需要从头来过
//逻辑不明确,只是简单的封装
//2 类似于C#,逻辑明确
//3.4适用于属性和方法
//1直观体现的是类之间的继承,由于每次对象的定义无法被记录,导致代码重用性不高,只适合操作一些使用频率不高、有限使用次数的类
//2非常标准的类的声明,在明确类的属性和方法时,特别适合使用,如果不明确,只能通过动态添加来弥补;
//3很少单独使用,一般配合一个已经定义好的Class配合使用,定义的是会放置到原型区域的 部分
//4特别适合做一些有差异的对象的抽象类 
//5隐藏了继承细节,其他地方和第1种是相似的
//最终常规处理方案:提倡2.3.4的配合使用,用第2个方法定义在定义前就已经确定的属性和 方法,然后执行过程中或者获取对象的过程中,如果该属性或者方法明确的整个类的所有对象 的话,就使用3;否则使用4动态添加 

//封装:成员函数
//继承:A is a B,A就是B的子类,可重用性;多态才有可能,少写代码;
//多态

/*function Person(){
    this.name = "person";
    this.age = 25;
    this.sex = "male";
    this.displayPersonInfo = function (){
        document.writeObject(this);
    }
}
//对象冒充机制,来实现继承思路
function Teacher(){
    //将Person的构造函数来作为Teacher类中的teacher对象的属性值
    this.teacher = Person;
    //必须要写的一句话,如果有参数还必须附上相应的参数
    //有了这句话,才将刚才构造函数中所带的属性和方法真正放入了自己的类中
    //执行一次父类的构造函数,从而拥有父类的所有成员
    this.teacher();
    this.salary = 1000.0;
    this.displayPersonInfo = function (){
        document.writeSelf("老师的个人信息为");
        document.writeObject(this);
    }
}

function Student(){
    this.student = Person;
    this.student();
    this.fav = "异性";
    this.displayPersonInfo = function (){
        document.writeSelf("学生的个人信息为");
        document.writeObject(this);
    }
}

var tmpTeacher = new Teacher();
tmpTeacher.displayPersonInfo();
//JS是支持多继承,即一个类同时继承于几个类,只需要多给几个属性来存放各自类的构造函数即可
//JS虽然不支持重载,但是支持重写

var persons =  new Array();
var tmpTeacher = new Teacher();
var tmpStudent = new Student();
persons[0] = tmpTeacher;
persons[1] = tmpStudent;
for(var index = 0;index<persons.length;index++){
    persons[index].displayPersonInfo();
}*/
/*
function Person(){
    this.name = "zhangSan";
    this.age = 10;
    function displayInfo(remark){   
        document.writeSelf(this.name + remark);
    }
    return displayInfo;
}

var funDemo = Window.Person();
window.funDemo("是个好人");*/

//如果displayInfo的方法不调用本函数中的name属性,那么到这里为止Person对象就可以被GC垃圾回收机制回收?
//如果displayInfo的方法调用本函数中的name属性,那么因为funDemo要用displayInfo,要用name属性,故此时不能回收
//闭包和垃圾回收机制相关

function Person(){
    this.name = "zhangSan";
    function displayInfo(){
        document.writeSelf(this.name);
    }
    return displayInfo;
}
var funDemo = Person();
window.name = "123";
funDemo.call(window);
//call是指函数的调用,call中所传参数就是该函数的内部的this;
var tmpPerson = new Person();
document.write(tmpPerson.name);