ES6 提供了更接近传统语言的写法，引入了 Class(类)这个概念，作为对象的模板。

通过 class 关键字，可以定义类。基本上，ES6 的 class 可以看作只是个语法糖，它的绝大部分功

能，ES5 都可以做到，新的class写法只是让对象原型的写法

更加清晰、更像面向对象编程的语法。

1. class声明类
2. constructor 定义构造函数初始化
3. extends继承父类
4. super 调用父级构造方法
5. static 定义静态方法和属性
6. 父类方法可以重写

// 构造函数
function Phone(brand,price){
    this.brand = brand
    this.price = price
}
Phone.prototype.call = function(){
    console.log("我可u打电话！")
}
let Huawei = new Phone('华为'，5999)
Huawei.call()

// class
class Phone{
    // 构造方法 名字不能修改
    constructor(brand,price){
        // 构造器的this——类的实例对象
        this.brand = brand
        this.price = price
    }
    // 方法必须使用该语法，不能使用ES5的对象完整形式
    // call方法——放在类的原型对象上，供实例使用
    // 通过Phone实例调用call时，call中的this就是Phone实例
    call(){
        console.log(`牌子是${this.brand}，价格是${this.price}`)
    }
}

let onePlus = new Phone("1+",1999)
console.log(onePlus)
onePlus.call()

类的静态成员

static 关键字属于类，而不属于实例对象

function Phone{
    
}
Phone.name = '手机'
Phone.change = function(){
    console.log("我可以改变世界")
}

let nokia = new Phone()
console.log(nokia.name) // undefined --> 称为静态成员


class Phone{
    // 静态属性
	static name = '手机'
	static change(){
    	console.log("我可以改变世界")
	}
}
let nokia = new Phone()
console.log(nokia.name) // undefined

类继承

ES5构造函数继承

// 手机（父级）
function Phone(brand,price){
    this.brand = brand
    this.price = price
}
Phone.prototype.call = function(){
    console.log("我可u打电话！")
}

// 智能手机（子级）
function SmartPhone(brand,price,color,size){
    Phone.call(this,brand,price) // 调用父类的构造函数
    this.color = color
    this.size = size
}
// 设置子级构造函数的原型（我的实例对象原型有父级的方法）
SmartPhone.prototype = new Phone

// 声明子类的方法
SmartPhone.prototypr.photo = function(){
    console.log("我可以拍照！")
}
SmartPhone.prototypr.playGame = function(){
    console.log("我可以玩游戏！")
}

const chuizi = new SmartPhone('锤子',2499,'黑色','5.5inch')

ES6类继承

// 父类
class Phone{
    // 构造方法 名字不能修改
    constructor(brand,price){
        this.brand = brand
        this.price = price
    }
    // 方法必须使用该语法，不能使用ES5的对象完整形式
    call(){
        console.log("我可u打电话！")
    }
}

class SmartPhone extends Phone{
    // 构造方法
    constructor(brand,price,color,size){
        super(brand,price) // 调用父类的构造函数
            this.color = color
		    this.size = size
    }
    photo(){
        console.log("拍照")
    }
    playGame(){
        console.log("玩游戏")
    }
}

const xiaomi = new SmartPhone('小米',799,'黑色','4.7inch')

子类对父类的重写

在子类声明跟父类同名的方法

// 父类
class Phone{
    // 构造方法 名字不能修改
    constructor(brand,price){
        this.brand = brand
        this.price = price
    }
    // 方法必须使用该语法，不能使用ES5的对象完整形式
    call(){
        console.log("我可以打电话！")
    }
}

class SmartPhone extends Phone{
    // 构造方法
    constructor(brand,price,color,size){
        super(brand,price) // 调用父类的构造函数
            this.color = color
		    this.size = size
    }
    photo(){
        console.log("拍照")
    }
    playGame(){
        console.log("玩游戏")
    }
    call(){
        console.log("我可以视频电话！")
    }
}

const xiaomi = new SmartPhone('小米',799,'黑色','4.7inch')

get和set

// get和set
class Phone{
    get price(){
        console.log('价格属性被读取了')
        return '￥900'
    }
    set peice(newVal){
        console.log('价格属性被修改了')
    }
}

// 实例化对象
let s = new Phone()
// console.log(s.price) // ￥900
s.price = 'free'

类中可以直接写赋值语句

class Car{
    constructor(name,price){
        this.name = name
        this.price = price
    }
    // 给Car的实例对象添加一个属性，名为a,值为1
    a = 1
}

const c1 = new Car('奔驰',111)

总结：

1. 类中的构造器不是必须要写的，要对实例进行一些初始化的操作，如添加指定属性时才写。
2. 如果A类继承了B类，且A类中写了构造器，那么A类构造器中的super是必须要调用的。
3. 类中所定义的方法，都放在了类的原型对象上，供实例去使用。