回顾JavaScript基础——面向对象

1：定义class

//定义class类
class Employee {
    //构造方法 constructor关键字，不可更改
    constructor(name,age){
        this.name = name ;
        this.age = age ;
    }
}
var emp = Employee("z",20);
console.log(emp);//输出结果：[name:"z",age: 20]

2：成员方法

class Employee {
    constructor(name,age){
        this.name = name ;
        this.age = age ;
    }
    signIn(){
        console.log(this.name+"男");
    }
    get info(){
        this.info = this.name + " " + this.age
    }
    set info(info){
        let [name,age ] = info.split(" ");//用空格解构出来
        this.name = name;
        this.age = age;
    }
}
var emp = Employee("z",20);
emp.signIn();
console.log(emp.info);//输出结果：z 20
//修改他的值
emp.info = "h 19";
console.log(emp.info);//输出结果：h 19

1）getter和setters关键字和原生js的一样，也是使用get和set关键字

3：面向对象实现继承 使用extends关键字

class Father {
    constructor(name,age){
        this.name = name ;
        this.age = age ;
    }
}
//定义一个新的类Son继承上面的Father类
class Son extends Father {
    
}
//创建一个实例
var son1 = new Son("q",20);
console.log(son1);//输出结果：[name:"q" , age:20]

//添加新的属性
son1.num = 5;
console.log(son1);//输出结果：[name:"q" , age:20 , num:5 ]

1）调用父类的构造函数来扩展子类的属性，使用super关键字来代表父类自身

class Father {
    constructor(name,age){
        this.name = name ;
        this.age = age ;
    }
}
//定义一个新的类Son继承上面的Father类
class Son extends Father {
    constructor(name,age,num){
        //使用super关键字来代替父类本身，来实现传值
        super(name,age);
        this.num = num;
    }
}
//创建一个实例
var son1 = new Son("q",20,5);
console.log(son1);//输出结果：[name:"q" , age:20 , num:5]

2）使用super关键字调用父类的其他方法

class Father {
    constructor(name,age){
        this.name = name ;
        this.age = age ;
    }
    signIn(){
        console.log(this.name+"mmp");
    }
}
//定义一个新的类Son继承上面的Father类
class Son extends Father {
    constructor(name,age,num){
        //使用super关键字来代替父类本身，来实现传值
        super(name,age);
        this.num = num;
    }
    //定义子类自己的方法
    signIn(){
        //使用super关键字调用父类的方法
        super.signIn();
        //输出子类方法自己的信息
        console.log(this.name+"nmd");
    }
}
//创建一个实例
var son1 = new Son("q",20,5);
console.log(son1);//输出结果：[name:"q" , age:20 , num:5]
//子类调用自己的方法，方法内会通过super关键字继承父类的方法，并输出自己的信息
son1.signIn();

4：成员变量（新）

class Employee {
    num = "";
}
var emp = new Employee();
console.log(emp);//输出结果：[num:""]
emp.num=5;
console.log(emp);//输出结果：[num:5]

5：静态成员（新） static

1）静态成员变量是class级别的，只能通过（类名.变量）来访问

class Page {
    static count = 0;
}
//只能通过.的方法来访问
Page.count++;
console.log(Page.count);//输出结果：1

2）静态成员方法和静态成员变量一样，只不过是定义了类中的方法 只能通过（类名.方法）来访问

class Page {
    static count = 0;
	static add(){
        Page.count++;
    }
}
//只能通过.的方法来访问
Page.add()；
console.log(count);//输出结果：1