高程3-面向对象
一、工厂模式:
function createPerson(name,age,job){
var o = new Object();
o.name=name;
o.age=age;
o.job=job;
o.sayName=function(){
alert(this.name)
}
return o;
}
创建实例:
var person1=createPerson();
var person2=createPerson();
优点:解决大量重复创建对象问题
缺点:没有解决对象识别问题,(怎么样知道一个对象的类型)
工厂模式就是函数的应用
二、构造函数:
function Person(name,age,job){
this.name=name;
this.age=age;
this.job=job;
this.sayName=function(){
alert(this.name)
}
}
var person1=new Person();
var person2=new Person();
注意:构造函数首字母大写,实例要New 出来;
构造函数内部执行:
1.创建对象
2.将构造函数作用域赋值给对象;
3.执行构造函数的代码
4.返回对象
优点:alert(person1.constructor==Person) true
alert(person2.constructor==Person) true
alert(person1 instanceof Object ) true
alert(person1 instanceof Person) true
alert(person2 instanceof Object ) true
alert(person2 instanceof Person) true
创建了特殊Person类
每个对象都有constructol(构造函数)属性,指向该实例的构造函数
instanceof 用来检测对象是否属于后面对象类型;、
缺点:构造函数实例中的方法重复创建,每个实例的方法都不是一个方法,,浪费资源;
alert(preson1.sayName==preson2.sayName) false
三、原型模式:
function Person(){}
Person.prototype.name="Nicholas";
Person.prototype.age=29;
Person.prototype.job="Soft....";
Person.prototype.sayName=function(){
alert(this.name)
}
var person1=new Person();
person1.sayName(); //"Nicholas";
var person2=new Person();
person2.sayName(); //"Nicholas";
alert(person1.sayName==person2.sayName); //true
优点:方法是一个,
缺点:属性定义在原型上了,也是一个,不够灵活
理解原型对象:
不论什么时候,创建一个函数就会有prototype(原型)属性,属性指向他的原型对象,默认情况下所有的原型对象都自动获得一个constructor(构造函数)属性
怎么确定是否是实例与原型的关系:
alert(Person.prototype,isPrototypeOf(person1))//true
ECMA5中增加的方法getPrototypeOf()获取他的原型;
alert(Object.getPrototypeOf(person1)==Person.prototype) //true
function Person(){}
Person.prototype.name="Nicholas";
Person.prototype.age=29;
Person.prototype.job="Soft....";
Person.prototype.sayName=function(){
alert(this.name)
}
var person1=new Person();
person1.name="Liang";
alert(person1.hasOwnProprety(name)) //true
alert(person1.name) //"Liang";
var person2=new Person();
alert(person2.name) //"Nicholas"
首先会现在实例中搜索有没有查找的内容,没有再向上搜索
delete person1.name; //会删除实例中的属性
alert(person1.name) //"Nicholas";
hasOwnProperty()检测属性是否存在某个实例(判断属性是实例,还是原型)
巧妙的 in 操作符
preson1.name='xxxx';
alert(name in preson1) //判断name是否是preson的属性 true
alert(name in preson2) //判断name是否是preson的属性,不是但是原型上有 true
判断属性存在原型还是实例函数
function hasPrototypeProprety(object,name){
return !object.hasOwnProprety(name)&&(name in object)
}
更简单的原型语法
function Person(){}
Person.prototype={
constructor:Person, //一定要加,默认没有构造函数属性
name:"liang", //一次可以添加多个属性,与方法
age:"18",
job:"So......",
sayName:function(){
alert(this.name)
}
}
ECMA5可以使用defineProperty重设构造函数
object.defineProperty(Person.prototype,"constructor",{
enumerable:false,
value:Person
})
四、 最常用的组合模式:构造函数+原型模式(组合模式)
属性写在构造函数中,方法写在原型中,
function Person(name,age,job){
this.name=name;
this.age=age;
this.job=job;
this.friends=["Shelby","Court"];
}
Person.prototype={
constructor:Person,
sayName:function(){
alert(this.name)
}
}
不同的属性,相同的方法
五、 动态原型模式
function Person(name,age,job){
this.name=name;
this.age=age;
this.job=job;
if(typeOf this.sayName!='function'){
Person.prototype.sayName=function(){
alert(this.name)
}
}
}
var friend=new Person("Liang",29,"asdasd");
friend.sayName(); //因为没有这个方法,所以创建了并使用
六、稳妥构造函数模式
没有this,new
function Person(name,age,job){
//创建要返回的对象
var o=new Object();
//在O中添加属性
o.age=age;
//在O中添加方法
o.sayName=function(){
alert(name)
}
//返回对象
return o
}
这样friend中保存的是一个稳妥对象,而除了调用sayName()方法外,没有别的方法可以访问其数据成员,不可能有别的办法访问传入到构造函数中的原始数据。稳妥模式提高了安全性、
继承:
1.原型链继承:SubType.prototype=new SuperType(); SubType原型=SuperType的实例;实例的__proto__指向所属SuperType类的原型,SubType原型指向SuperType所属累的原型
确定原型和实例的关系
alert(instance instanceOf Object); //true
alert(instance instanceOf SuberType); //true
alert(instance instanceOf SubType); //true
是否是某构造函数的实例
alert(Object.prototype.isPrototypeOf(instance)) true
alert(SuberType.prototype.isPrototypeOf(instance)) true
alert(SubType.prototype.isPrototypeOf(instance)) true
只要是原型链派生出的实例原型,都是ture