ES6-类

在了解类之前，得先了解js是什么语言？

js是一个基于面向对象设计的单线程的静态脚本语言.

面向对象  ( 类 实例对象 继承 封装 多态 )

基于面向对象设计  

        本质没有继承 类 等等语法  但是按照自己的语法特征(原型)

单线程  

        代码只能一个业务一个业务的执行

静态

         var a={};  var re=a*20;

脚本语言  > 嵌入式语言 灵活

ES6中为了更加好的把js设计成面向对象的语言的语法特征引入了类这个概念

类的语法：

声明一个类：

 class Person{
			
}

因为js并不是一个面向对象的语言所以，这里的类实质上是一个函数

每个类中包含了一个特殊的方法 constructor()，它是类的构造函数，这种方法用于创建和初始化一个由 class 创建的对象。

构造方法是一种特殊的方法：

• 构造方法名 constructor()。
• 构造方法在创建新对象时会自动执行。
• 构造方法用于初始化对象属性。
• 如果不定义构造方法，JavaScript 会自动添加一个空的构造方法。

            class Person{
				constructor(life,age){
					this.life=life
					this.age=age
				}
            }

以上实例中初始化了一个类 Person，创建了两个类的属性,life,age

类的定义一共有两种一种是匿名类，一种是非匿名类：

匿名类：

let p = class{

}
console.log(p.name)

打印结果为p

非匿名类：
 

let p2 = class Person{

}
console.log(p2.name)

打印结果为Perso

用new关键字来创建对象：

            class Person{
				constructor(life,age){
					this.life=life
					this.age=age
				}
            }
             let person = new Person(1,20)
             console.log(person.life,person.age)

分别打印1，和20

类的方法

我们使用关键字 class 创建一个类，可以添加一个 constructor() 方法，然后添加任意数量的方法。

如：

class Person{
				constructor(life,age){
					this.life=life
					this.age=age
				}
                others1(){...}
                others2(){...}
                others3(){...}
            }

静态方法，静态属性：

用​​​​​​​static进行修饰

静态方法和实例方法的区别

静态方法不需要通过new创建对象进行调用，可以直接类名.方法名进行调用，

class People {
	static sum(a, b) {
		console.log(a + b);
	}
}
People.sum(1, 2);

实例方法则需要通过new创建对象然后，对象名.方法名进行调用

class People {
	sum(a, b) {
		console.log(a + b);
	}
}
let p = new People(1,2)
p.sum(1,2)

类的继承

• 解决代码的复用

• 使用extends关键字实现继承

• 子类可以继承父类中所有的方法和属性

• 子类只能继承一个父类（单继承），一个父类可以有多个子类

• 子类的构造方法中必须有super()来指定调用父类的构造方法，并且位于子类构造方法中的第一行

• 子类中如果有与父类相同的方法和属性，将会优先使用子类的（覆盖）

class People {
    //父类构造方法
	constructor() {
        this.a = 100; //父类中定义的变量
		console.log("People constructor");
	}
    //原型方法
	eat() {
		console.log("eat...")
	}
    //静态方法
    static play() {
		console.log("play...")
	}
}
			
class Student extends People {
    //子类构造方法
	constructor() {
		super(); //调用父类构造器，必须存在，且位于子类构造器第一行的位置
        this.b = 200; //子类定义的变量
		console.log("Student constructor");
	}
	study() {
		console.log("study...");
	}
}
			
let stu = new Student();
console.log(stu.a， stu.b);
stu.eat();
stu.study();
Student.play();

内部类：属于外部类的成员，必须通过“外部类.内部类”访问

// 外部类
class Outer {
	constructor() {
         console.log("outer");
    }
}
// 内部类
Outer.Inner = class {
    constructor() {
         console.log("Inner");
    }
}     
new Outer.Inner();