k_class

class

	//es5 中通过原型来继承
	function Pa(x,y){
		//构造函数中写属性
		this.x=x;
		this.y=y;
	}
	//原型上写 公共属性或方法
	Pa.prototype.say=function(){
		console.log(this.x);
	}
	//new 一个实例   实例就会有原型上的方法 和构造函数中的属性
	
	let p=new Pa("a",2);
	p.say();  // a

	//es6 中跟es5是一样的   写法不同而已 
	// es5  构造函数和原型对象分开写,
	// es6 是全部写到class中
	
	class Pa{
	//constructor  就是es5中的构造函数
	  constructor(x, y) {
	    this.x = x;
	    this.y = y;
	  }
	  //不需要分割符，直接写  原型方法
	  say() {
	   console.log(this.x);
	  }
	}
	let p=new Pa("a",2);
	p.say(); //a
	
	console.log(Pa == Pa.prototype.constructor); //true
	//Pa 就是那个构造函数

类的内部方法不可枚举

	//es5
	function Pa(){};
	Pa.prototype.b="1"
	let p=new Pa();
	console.log(Object.keys(p)); //[]  遍历对象上的属性名 不会遍历原型对象上的属性
	console.log(Object.keys(Pa.prototype)); //["b"]    原型对象是一个对象 列出对象的key
	
	//es6
	class Ku {
		c(){ 
			 console.log(132);
		}
	};
	console.log(Object.keys(Ku.prototype)); //[]   类的内部所有定义的方法，都是不可枚举的

---

	class Pa {
	}

	// 等同于
	class Pa {
	  constructor() {}
	}

---

class 上面的属性

	class Ku {
		constructor() {
		  this.x = 8;
		  this.y = 9;  //属性最好的归处
		}
		a=1; //实例的属性   直接 = 
		// b:2    写法不对
		c(){
			console.log("55");
		}
	}

	let k=new Ku();
	console.log(k.a); //1
	console.log(k.x); //8
	k.c();	//55
	
	// Object的hasOwnProperty()方法返回一个布尔值，判断对象是否包含特定的自身（非继承）属性。
	
	console.log(k.hasOwnProperty("x"));  //true    自己的或构造函数的
	console.log(k.hasOwnProperty("a"));  //true
	console.log(k.hasOwnProperty("c"));  //false    原型上的方法

静态方法

	// 静态方法   该方法不会被实例继承，而是直接通过类来调用
	//使用  在一个方法前，加上static关键字

	class Pa{
		static see(){
			console.log("look");
		}
		say(){
			console.log("hahaha~");
		}
	}
	
	Pa.see(); //look   
	
	let p=new Pa();  //class  需要new 
	p.say();  //hahaha~
	p.see();   //p.see is not a function   实例没有静态方法

	// 静态属性  
	//ES6 明确规定，Class 内部只有静态方法，没有静态属性。

	class Pa{};
	Pa.a=1;
	
	let p=new Pa();  
	
	console.log(Pa.a); //1   类直接调用静态属性
	console.log(p.a);  //undefined     实例没有继承静态属性