1、基本写法
class test {
constructor(x,y) {
}
print(a) {
console.log(a)
}
}
var Test = new test()
Test.print(213)
2、class 的getter和setter
var mm = 123;
console.log(mm) //123
class test {
constructor(x, y) {
}
get value() {
return mm
}
set value(a) {
mm = a
}
}
var Test = new test();
Test.value = 213; //设置成功
Test.value //获取成功
console.log(mm) //213
3、静态方法
- 类相当于实例的原型，所有在类中定义的方法，都会被实例继承。如果在一个方法前，加上static关键字，就表示该方法不会被实例继承，而是直接通过类来调用，这就称为“静态方法”。
class test {
constructor() {
}
static print (a) {
console.log(a)
}
}
var Test = new test();
test.print(123) //123，静态方法只有构造函数可以调用
Test.print(123) //报错,说明这个实例上面没有这个print方法
4、class的继承的基本写法
class A {
constructor() {
}
}
class B extends A {
constructor () {
super() //这个调用是必须的，相当于把A的方法给执行一遍
}
}
tip：继承会把父类的所有方法都给继承过来，包括static静态方法
5、class里面的super
super这个关键字，既可以当作函数使用，也可以当作对象使用
- 当函数使用
class A {
constructor() {
}
}
class B extends A {
constructor () {
this.b= 222 //只有调用super之后，才可以使用this关键字，否则会报错,因为子类的构建依赖父类
super() //super()只能使用在constructor
}
}
- 当对象使用
第一种情况
class A {
constructor() {
this.x = 1;
}
pp() {
console.log(this.x)
}
}
class B extends A {
constructor () {
super()；
this.x = 2;
}
mm () {
super.pp(); //这个super指的是构造函数A
}
}
let b= new B();
b.mm() //2
分析：b.mm（） 结果为2是因为在执行super.pp()时，里面的this指的是B里面的this，所以为2；
第二种情况(此处有疑问，用nodejs结果打印this.x结果是3,super.x可以修改，但是用webpack的就不可以）
class A {
constructor() {
this.x = 1;
}
}
A.prototype.x = 111
class B extends A {
constructor() {
super();
this.x = 2;
super.x = 3;
console.log(super.x); // 111 (super.x的值不能更改)
console.log(this.x); // 2
}
}
let b = new B();
解析： super.x里面的值指的是A.prototype.x的值，同时super.x不能修改A.prototype.x的值
6、类的 prototype 属性和proto属性
（1）子类的proto属性，表示构造函数的继承，总是指向父类。
（2）子类prototype属性的proto属性，表示方法的继承，总是指向父类的prototype属性。
（总结：就是说继承过来的构造函数上的proto指的是父类，原先构造函数上面没有proto，只有实例对象有，比如构造函数的prototype
=== 实例对象的proto）
- 这是继承的构造函数的proto
class A {
}
class B extends A {
}
B.__proto__ === A // true
B.prototype.__proto__ === A.prototype // true
- 这是继承的实例对象的proto
var p1 = new Point(2, 3);
var p2 = new ColorPoint(2, 3, 'red');
p2.__proto__ === p1.__proto__ // false
p2.__proto__.__proto__ === p1.__proto__ // true
子类实例的proto属性的proto属性，指向父类实例的proto属性。也就是说，子类的原型的原型，是父类的原型。
网友评论