typescript 学习 系列 （六）

// 1.abstract 抽象类：就是把共用的东西进行封装。    只能被继承，不能实例化
	abstract class chouxiangA {
	      name :string = '抽象类';
	      // 就是你知道下面类中都有这个方法，但是你不知道方法里具体写什么。这样的话定义abstract
	      abstract getName() :string
  	}
  	// 类一
  	class chouxiangB extends chouxiangA{
    	getName(){
      		return this.name
    	}
 	}
  	var chouxiangQ = new chouxiangB()
  	console.log(chouxiangQ.getName()).    //抽象类
  	
  	// 类二
  	class chouxiangC extends chouxiangA{
    	getName(){
      		return 'abstract'
    	}
  	}
  	var chouxiangQ = new chouxiangC()
  	console.log(chouxiangQ.getName())   //abstract


// 2.类应用一个接口 implements,  一个类可以定义多个接口
	interface yingyongA {
		name : string
	}
	interface yingyongD {
		set():string
	}
	
	class yingyongB implements yingyongA,yingyongD{
		name = 'zqc';
		set(){
			return 'string'
		}
	}

// 3.联合类型（|）和类型保护  
	interface Dog {
	  	fly:boolean,
	  	sing:()=>{}
	}
	interface Ren {
	  	fly:boolean,
	  	chi:()=>{}
	}

// 类型保护的方式
	// 1.类型断言的方式
	function leixingduanyan(animal:Dog | Ren){
  		// animal.chi()  //这个时候调用chi就会报错，因为不确定是否有chi
  		(animal as Ren).chi()  //类型断言，可以让程序知道是否有这个方法。可以防止报错。
	}
	// 2.in 语法
	function leixingduanyan1(animal:Dog | Ren){
	  	if('chi' in animal){
	    	animal.chi()
	  	}else{
	    	animal.sing()
	  	}
	}
	//3.typeof语法来做类型保护
		function add(first: string | number, second: string | number) {
	  	// 这样的话就会报错，不确定这两个参数加起来的类型返回是什么
	  	//   return first + second;
	  	if (typeof first === 'string' || typeof second === 'string') {
	      	return `${first}${second}`
	  	}else{
	    	return first + second;
	  	}
	}
	// 4.instanceof 进行类型保护。  
	// NumberObj 必须使用class声明，不能使用interface。只有class里面才有instanceof
	class NumberObj {
	  	count: number;
	}
	function addSecond(first: object | NumberObj, second: object | NumberObj ){
	  	// return first.count + second. count;
	  	if (first instanceof NumberObj && second instanceof NumberObj) { 
	    	return first.count + second. count;  
	  	}
	}