类继承的时候可以继承属性和方法,
//ES6语法,class方法,同java
class Person{
constructor(name){
this.name = name;
}
drink(){
console.log('drink')
}
}
class Student extends Person{//使用extends继承
constructor(name,score){
super(name)//使用super关键字执行父类的构造函数
this.score = score
}
}
class Teacher extends Person{//使用extends继承
constructor(name,sub){
super(name)//使用super调用父类构造函数
this.sub= sub
}
}
const student = new Student('amy',99)
student.drink()//调用父类方法
//原型链方法
//优点:简单
//缺点:属性被实例共享,不能向父类传递参数
function Parent(){
this.name = 'Parent'
this.play= [1,2,3]
}
function Child(){
this.type = 'Child'
}
Child.prototype = new Parent()//在链上,但当使用同一个对象声明两个实例时,修改其中一个,另一个也修改
const s1 = new Child()
const s2 = new Child()
s1.play.push(4)
//此时s1、s2的play属性都是[1,2,3,4]
//借用构造函数
//优点:避免了共享,可以向父类传递参数
//缺点:方法在构造函数中定义,创建实例都会创建一遍方法
function Parent(){
this.name = 'Parent'
}
function Child(){
Parent.call(this)
this.type = 'Child'
}
//组合继承
//最常用,
//调用了两次父亲的构造函数
function Parent(){}
function Child(){
Parent.call(tihs)
}
Child.prototype = new Parent();
Child.prototype.constructor = Child;
//原型式继承(Object.create())
//优点:简单
//缺点:属性被实例共享
function CreateObj(o){
function F(){}
F.prototype = o;
return new F();
}
//寄生式继承
//缺点:方法在构造函数中定义,创建实例都会创建一遍方法
function createObj(o){
var clone = Object.create(o);
clone.sayName = function(){}
return clone;
}
//寄生组合式继承(最理想)
//优点高效率,只调用一次父构造函数,原型链不变
function Parent(){}
function Child(){
Parent.call(tihs)
}
var F= function(){}
F.prototype = Parent.prototype;
Child.prototype = new F()