L_class_继承

原型链的继承

extends 继承

	class A{
		constructor(x) {
		    this.x=x;
		}
		say(){
			console.log(this.x);
		}
	}
	let a=new A(6);
	a.say();//6
	
	// B继承A
	class B extends A{
		constructor(x,y){//B 自己的构造函数   构造函数通过new 会生成实例
			
			super(x,y);
			//super(x)，代表调用A的构造函数constructor(x)。 但是返回的是子类B的实例
			//super()在这里相当于A.prototype.constructor.call(this)。 this指的是B 
			//super 之后才能使用this
			
			this.y=y; //B自己的属性
		}
	}
	let b=new B(5,9);
	
	b.say(); //5
	console.log(b.y)//9

	class ColorPoint extends Point {
	}

	// 等同于
	class ColorPoint extends Point {
	  constructor(...args) {
		super(...args);
	  }
	}

---

super 关键字

	//既可以当作函数使用，也可以当作对象使用。

	//当作函数使用,代表父类的构造函数,且只能用在子类的构造函数之中
	class A {}
	class B extends A {
	  constructor() {
	    super();
	  }
	}

	//super作为对象时  指向父类的原型对象
	class A {
		constructor() {
			//实例的方法
		    this.x=function(){
				return 1;
			};
		}
		//原型上的方法
		p() {
			return 2;
		}
	}

	class B extends A {
	  constructor() {
		super();
		console.log(super.p()); // 2
		console.log(super.x()); // x is not a function
		//A.prototype 的原型上没有x方法 就找不到
		//super  是指向 A.prototype的
	  }
	}

	let b = new B();

静态方法

	//super作为对象时  指向父类的原型对象
	class A {
		static say(){
			console.log("132");
		}
	}
	A.say();//132
	class B extends A {
		kk(){
			console.log("kk"); //kk
			super.say();   //super 没有这个say方法
			//作为对象 super在普通方法之中指向父类的原型对象。
		}
		static gg(){
			console.log("gg"); //gg
			super.say(); //132
			//作为对象   super在静态方法之中指向父类
		}
		
	}
	let b = new B();
	b.kk();   //kk   .say is not a function    
	B.gg();    //静态方法 所以用B 调用