TS基础之（三）TS中的类

TS中的类

    首先确认es5中的类
			
            
简单写一个类~

				
					function fun(name,age){
						this.name = name;
						this.age = age;
						this.run = function(){
							console.log(111111)
						}
					}
					let f = new fun();
					f.run()
				
			
对象继承

			
			    function father(name,age){
			    	this.name = name;
			    	this.age = age;
			    	this.run = function(){
			    		console.log(111111)
			    	}
			    }
			    let f = new father();
			    father.prototype.eat = function(){
			    	console.log('i want meat!')
			    }
			    function son(){
			    	father.call(this, 'zhangsan', 12); //继承构造函数里面的方法和属性;
			    }
			    //此项继承无法继承原型链上面的属性及方法;既son中没有eat方法；
			    
				//son.prototype = new father();
			    son.prototype = father.prototype;//原型链继承;此方法无法传值;
			    
			    let s = new son(); //组合方法即可;
			
			
类的类型

			基本除声明变量类型外同es6及c#，声明在属性及方法上面
			
public公有

			
				//在类里面，子类里面，类外面都可以访问；
				不举例子了~
			
			
protected保护类型

			
				//在类里面，子类里面可以访问，类外面无法访问；
				class Father{
					protected name:string;
					constructor(name:string){
						this.name = name;
					}
				}
				let f = new Father('mingzi');
				alert(f.name);
				//保护类型外部无法访问；
			
			
private保护类型

			
				//在类里面可以访问；子类里面、类外面无法访问；
				class Father{
					protected name:string;
					constructor(name:string){
						this.name = name;
					}
				}
				class Son extends Father{
					constructor(name:string){
						super(name)
					}
					run(){
						console.log(this.name)//子类无法访问；
					}
				}
				let f = new Father('mingzi');
				alert(f.name);//外部无法访问；
				//保护类型外部无法访问；
			
			
静态方法

			
				//es5中的静态方法；
				function Father{
					this.run = function(){
						
					}
				}
				father.work = function(){
					
				}
				//~~~~ TS中的静态方法；~~~~ 
				class Father{
					protected name:string;
					static dos = 1;
					constructor(name:string){
						this.name = name;
					}
					static work(){
						console.log(1,Father.dos)//静态方法中调用的参数也是静态参数；无法调用未实例的参数；
					}
				}
				Father.work();//调用静态方法不需要实例化;
			
			jQuery中的$是一个声明的对象；$直接点出来的就是静态方法
			
多态

			父类定义一个方法不去实现，不同的子类重写这个方法去做不同的实现；就是多态（后有对于多态的拓展）
			
				class Father{
					name:string; //不申明类型，磨人的就是public；
					constructor(name:string){
						this.name = name;
					}
					run(){
						console.log(111111)
					}
				}
				class Son1 extends Father{
					constructor(){
					}
					run(){
						console.log('son1')
					}
				}
				class Son2 extends Father{
					constructor(){
					}
					run(){
						console.log('son2')
					}
				}
			
			
抽象类

			抽象类和抽象方法用来定义标准；属于是多态的拓展；关键字abstract
			
				abstract class Father{
					name:string;
					constructor(){
					}
					abstract run():any;//使用关键字声明之后，子类必须要声明这个方法；	不用写代码块，否则报错
				}
				class Son1 extends Father{
					run(){
						console.log(111)
					}
				}
				class Son2 extends Father{
					run(){
						console.log(2222)
					}
				}
				如果实例化抽象类会报错；只能通过子类；abstr方法只能放在抽象类里面
				
					如果父类constructor中有参数传入；子类中必须有对应得参数传入；
				

1、TS基础之（一）数据类型（变量）声明

2、TS基础之（二）函数声明及参数类型

4、TS基础之（四）TS中的接口 interface

5、TS基础之（五）TS中的泛型