js之ES6的Class类 / 开普饭

JavaScript ES6之前的还没有Class类的概念，生成实例对象的传统方法是通过构造函数。

例如：

1 function Mold(a,b){
2                  this.a=a;
3                  this.b=b;
4          }
5          Mold.prototype.count=function(){
6              return this.a+this.b;
7          };
8          let sum=new Mold(1,2);
9         console.log(sum.count())　　//3

这中写法跟传统的面向对象语言差异较大，写起来也比较繁杂。

ES6提供了更加接近其他语言的写法，引入了Class（类）的概念，作为对象的模板，可以通过class关键字，定义类（类似python、java等）；

当然ES6的大部分功能再ES5都能实现，ES6的class可以看作是一个语法糖，只是新的class定义类的写法让对象原型的写法更加简单明了、更接近与面向对象的编程思想。与上面ES5写的类使用ES6实现，例如：

1 class Mold{
 2              constructor(a,b){
 3                  this.a=a;
 4                  this.b=b;
 5              }
 6              count(){
 7                  return this.a+this.b;
 8              }
 9         }
10         let sum=new Mold(1,2);
11         console.log(sum.count())　　//3

这里ES6的类，只需用class定义，并且类的方法不需要用function定义；还有ES6的constructor方法，代表这该类的构造方法；并且它的this关键字指向着实例对象。这里ES5的构造函数Mold，相当于ES6Mold类的constructor方法。

constructor
- ES6实例对象的构造函数就是该类本身；并且当我们new 类名()就是执行了constructor这个函数。

例如：

1   class Mold{
2              constructor(){
3                 console.log("aaa")
4              }
5         }
6  let m=new Mold();// aaa
7  console.log(m.constructor===Mold);//true

上面代码Mold类的constructor，实例化对象时执行默认constructor；

- 任何对象都有构造函数，并且构造函数与当前对象的类是相同；

例如：

1 let arr=new Array();
2  console.log(arr.constructor===Array);//true
3  let str=new String();
4  console.log(str.constructor===String);//true
5  let obj=new Object();
6  console.log(obj.constructor===Object);//true

　　2. 类的继承 extends

- 继承父类后，子类会继承父类所有的方法和属性(包括静态方法和属性)
- 如果子类没有定义constructor方法，会默认被添加该方法
- 任何子类都有constructor方法;

例如：

1 //class 类名 extends 被继承的类{}
 2 Class Father{
 3       constructor(){
 4       }
 5      sum(){
 6          console.log("abc");
 7      }
 8      static fn(){
 9          console.log("hello")
10      }
11  }
12  Class Son extends Father{
13
14  }
15  let s=new Son();
16  s.sum()//abc,继承了父类的sum()方法
17  Son.fn()//hello 继承了父类的静态方法fn()

- 继承后的子类方法的三种处理：

1). 完全继承，不需要重写这个方法，子类执行继承方法内容与父类相同

2). 重写覆盖，只需要在这个类中重写这个方法就可以覆盖继承过来的内容

3). 加工，子类可以用super调用父类的方法或属性进行加工，再加上子类自己的方法和属性

　　3. super

- 调用父类的构造函数直接使用super()，并且可以传参；
- 子类的构造函数中，只有调用了super之后才可以使用this关键字，否则会报错;

例如：

1 //super.父类函数()；
 2  class Father{
 3       constructor(){
 4         console.log("bbb");
 5      }
 6  }
 7  class Son extends Father{
 8      constructor(x){
 9         this.x=x;//ReferenceError,报错
10         super();
11         this.x=x;//正确
12      }
13  }
14  let sum=new Son();//bbb

　　4. 类的static静态

- 在属性或方法前面使用 static定义类的静态属性和方法；
- 所有的静态属性和静态方法都不能通过实例化的对象调用；
- 需要通过类来调用,静态属性和静态方法是类的专属属性和方法，和实例化对象无关，比如数组和数学方法中的：Array.from();Math.random（）。

例如：

1 class Mold{
 2          static x=0;
 3          y=1;
 4          static fn1(){
 5              console.log("aaa")
 6          }
 7          fn2(){
 8              console.log("bbb");
 9          }
10         }
11      let m=new Mold();
12      console.log(m.x,m.y);//undefined , 1
13      m.fn1(); // TypeError
14      m.fn2(); // bbb
15      //需要通过类来调用
16      Mold.fn1(); //aaa
17      console.log(Mold.x);//0

- 静态的使用场景：

一般静态的方法是用来解决一系列该类型的方法；

解决具体类型的方法,不是解决某个具体对象的方法

静态属性,一般用于存储该类型的一系列通用的属性变量

这种存储,在类创建的时候就已经变成全局的了,可在任何地方调用,并且不会被自动销毁

js之ES6的Class类

相关推荐