es6构造函数是不是只能有一个

//1、利用newObject()创建对象
varobj1=newObject();

//2、利用对象字面量创建对象
varobj2={};

//利用构造函数创建对象
functionStar(name,age){
this.name=name;
this.age=age;
this.sing=function(){
console.log('唱歌');
}
}

varldh=newStar('刘德华',23);
console.log(ldh);
ldh.sing();
//Star{name:'刘德华',age:23,sing:[Function(anonymous)]}
//唱歌

//类的声明
classPerson{
//类的构造方法注：一个类只能有一个构造函数,如果没有定义那就自动用默认的
//通过new关键字操作类的时候，会调用constructor函数，并执行如下操作
//1、在内存中创建一个对象moni={}
//2、将类的原型prototype赋值给创建出来的对象moni.__proto__=Person.prototype
//3、将对象赋值给函数的this：new绑定this=moni
//4、执行函数中的代码
//5、自动返回创建出来的对象
constructor(){
}
}


letp1=newPerson()

letP2=newPerson('kobe',30)

/免费云主机域名/构造函数中的属性和方法称为成员
functionStar(uname,age){
this.uname=uname;
this.age=age;
this.sing=function(){
console.log('我会唱歌');

}
}
varldh=newStar('刘德华',18);

//1、实例成员就是构造函数内部通过this添加的成员
//uname、age、sing就是实例成员
//实例成员只能通过实例化的对象来访问
console.log(ldh.uname);//刘德华
ldh.sing();//我会唱歌
//不可以通过构造函数来访问实例成员
console.log(Star.uname);//undefined

Star.sex='男'
//2、静态成员在构造函数本身上添加的成员sex就是静态成员
//静态成员只能通过构造函数来访问
console.log(Star.sex);//男
//静态成员不能通过对象来访问
console.log(ldh.sex);//undefined

functionStar(uname,age){
this.uname=uname;
this.age=age;
this.sing=function(){
console.log('我会唱歌');
}
}
console.dir(Star);

functionStar(uname,age){
this.uname=uname;
this.age=age;
//this.sing=function(){
//console.log('我会唱歌');
//}
}
Star.prototype.sing=function(){
console.log('我会唱歌');
}
varldh=newStar('刘德华',18);
varzxy=newStar('张学友',19);
console.log(ldh.sing===zxy.sing);//采用this添加方法时输出false采用prototype添加方法时输出true
ldh.sing();
zxy.sing();

functionStar(uname,age){
this.uname=uname;
this.age=age;
}
Star.prototype.sing=function(){
console.log('我会唱歌');
}
varldh=newStar('刘德华',18);
varzxy=newStar('张学友',19);
console.log(ldh);
//对象身上系统自己添加一个__proto__指向构造函数的原型对象prototype
console.log(ldh.__proto__===Star.prototype);//true
//方法的查找规则(以sing方法为例)：
//首先看实例对象身上是否有sing方法，如果有就执行这个对象的sing
//如果没有sing方法，因为有__proto__的存在，就去构造函数原型对象prototype身上找sing方法

functionStar(uname,age){
this.uname=uname;
this.age=age;
}
Star.prototype={
//如果我们修改了原来的原型对象,给原型对象赋值的是一个对象,则必须手动的利用constructor指回原来的构造函数
constructor:Star,
sing:function(){
console.log('我会唱歌');
},
movie:function(){
console.log('我会演电影');
}
}
varldh=newStar('刘德华',18);
console.log(Star.prototype.constructor);
console.log(ldh.__proto__.constructor);

Star.prototype={
sing:function(){
console.log('我会唱歌');
},
movie:function(){
console.log('我会演电影');
}
}
console.dir(Star);

Star.prototype={
//如果我们修改了原来的原型对象,给原型对象赋值的是一个对象,则必须手动的利用constructor指回原来的构造函数
constructor:Star,
sing:function(){
console.log('我会唱歌');
},
movie:function(){
console.log('我会演电影');
}
}