ES6详细解说，基础教学（四）

十六、ES6中的面向对象

类的定义

语法：class 类名 {}

//定义类，关键词class
class Furist{

}
//类的使用(类的实例化)，关键词new
let f=new Furist();//f叫做类的引用

类中的结构

类中可以定义方法（函数），也可以定义属性。

类的方法

类中的方法包含3类，构造方法、成员方法、静态方法

构造方法

关键词constructor

语法：constructor(){}

class Fruit{
    constructor(){//类的构造方法
    }
}

成员方法

即一般普通的方法,

语法：方法名(参数){ }

class Fruit{
    aa(params) {}
    bb(){}
}

静态方法

语法：static 方法名(参数){}

class Fruit{
    static aa(params) {}
    static bb(){}
}

类方法的使用

class Friut{
    constructor(str){
        console.log("我是构造方法！"+str);
    }
    aa(){
        console.log("我是成员方法！");
    }
    static bb(){
        console.log("我是静态方法！");
    }
}
//如果需要使用类，必须要先创建类的实例。
let f=new Friut();//创建了一个Friut类的实例
//构造方法，在创建类的实例的时候被调用。
let f1=new Friut("我是憨憨");
//上面new的变量名，专业术语叫 类的引用。
//成员方法只能使用引用来调用
f.aa();
//静态方法只能使用类名来调用
Friut.bb();
Friut.aa();

类的属性

类中的属性的分类 2类，成员属性，静态属性。

成员属性

语法：属性名即可,可以在成员方法/构造方法中使用 this.属性名

注：如果在成员方法中定义的成员属性，需要调用成员方法才可以赋值。如果是静态方法中定义的属性，也需要调用静态方法才可以赋值。

静态属性

语法：在静态方法中使用 this.属性名 ,也可以在类中使用关键词 static 属性名

class User{
	interest="haha";
    static  username="rypy";
    constructor(){
    	this.username="rypy1"；
    }
    getPwd(){
    	this.pwd="123456";
    }
    static getSex(){
        this.sex="男";
    }
}
console.log(User.username);
User.getSex();
console.log(User.sex);

类的继承

类的继承 关键词 extends,语法：子类 extends 父类

**注：**ES6中类的继承，子类是完全继承父类的全部。

class Fruirt{
    sf=true;
    static wss="ABCDEFG";
    constructor(sf){
        //this.sf=sf;
    }
    eating(){
        console.log("我可以吃！");
    }
    static getPi(){
        console.log("我有皮");
    }
}
class Apple extends Fruirt{
}
let ap=new Apple(false);
console.log(Apple.wss);
console.log(ap.sf);
ap.eating()
Apple.getPi()

类的多态

成员方法/静态方法

成员属性/静态属性可以直接实现子类的多态，但是，如果构造方法需要实现多态，必须在子类中调用父类的构造方法。

子类中调用父类的构造方法，采用 super()。

class Fruirt{
    sf=true;
    static wss="ABCDEFG";
    constructor(sf){
        this.sf=sf;
    }
    eating(){
        console.log("我可以吃！");
    }
    static getPi(){
        console.log("我有皮");
    }
}
class Apple extends Fruirt{
    sf=false;
    constructor(){
        super("我是子类的父类");
        this.hh="我有核";
    }
    eating(){
        console.log("我还很绿，不能吃！");
    }
}
let f=new Fruirt();
let ap=new Apple();
console.log(ap.sf);
console.log(ap.hh);
ap.eating();
// let f=new Fruirt();
// console.log(f.sf);//undefined
console.log(f.sf);//undefined

使用new创建的实例，实例与实例之间互补干扰，各自有各自的作用域。

静态方法和静态属性

静态属性在用子类的类名重新赋值的时候，不会影响父类，但如果使用父类的类名给静态属性进行赋值，则会影响子类。

//情况一
// Apple.wss="我是重新赋值的内容";
// console.log(Fruirt.wss);
//情况二
Fruirt.wss="我是重新2";
console.log(Apple.wss);

super和this关键词

super关键词

用在子类中，

如果在子类中需要调用父类的成员方法，可以采用 super.方法名 来使用。注：只能使用在子类成员方法。

如果在子类中需要使用父类的静态方法，可以采用 super.方法名 来使用，但只能在子类的静态方法中使用。

如果在子类的成员方法中需要使用父类的静态方法，可以使用 类名.方法名来调用。

class Fruirt{
    sf=true;
    static wss="ABCDEFG";
    constructor(sf){
        this.sf=sf;
    }
    eating(){
        console.log("我可以吃！");
    }
    static getPi(){
        console.log("我有皮");
    }
}
class Apple extends Fruirt{
    sf=false;
    constructor(){
        super("我是子类的父类");
        this.hh="我有核";
    }
    eating(){
        super.eating();
        Fruirt.getPi();
        console.log("我还很绿，不能吃！");
    }
    static getPii(){
        super.getPi();
        console.log("我的皮是红色的");
    }
}
let ap=new Apple();
ap.eating();
// Apple.getPii();

this关键词

指向当前类，

this关键词可以让子类之间的方法进行互相调用。

规则，成员方法只能成员方法之间互调。静态方法只能静态方法之间互调。

规则，this 也可以在成员方法中调用成员属性，在静态方法中调用静态属性。

class Fruirt{
    sf=true;
    static wss="ABCDEFG";
    constructor(sf){
        this.sf=sf;
    }
    eating(){
        console.log("我可以吃！");
    }
    static getPi(){
        console.log("我有皮");
    }
}
class Apple extends Fruirt{
    sf=false;
    constructor(){
        super("我是子类的父类");
        this.hh="我有核";
    }
    eating(){
        this.eating2();
        console.log("我还很绿，不能吃！"+this.sf);
    }
    eating2(){
        console.log("我还很红了，可以吃！");
    }
}
let ap=new Apple();
ap.eating();