/*

 1、vscode配置自动编译

     1.第一步   tsc --inti 生成tsconfig.json   改 "outDir": "./js",  

     2、第二步 任务 - 运行任务  监视tsconfig.json

 2、typeScript中的数据类型

     typescript中为了使编写的代码更规范，更有利于维护，增加了类型校验，在typescript中主要给我们提供了以下数据类型

         布尔类型（boolean）

         数字类型（number）

         字符串类型(string)

         数组类型（array）

         元组类型（tuple）

         枚举类型（enum）

         任意类型（any）

         null 和 undefined

         void类型

         never类型

 3、typeScript中的函数

     3.1、函数的定义

     3.2、可选参数

     3.3、默认参数

     3.4、剩余参数

     3.5、函数重载

     3.6、箭头函数  es6

 4、typeScript中的类

     4.1 类的定义

     4.2 继承

     4.3 类里面的修饰符

     4.4 静态属性 静态方法

     4.5 抽象类 多态

 */

 // 静态属性 静态方法  

 /*

     function Person(){

         this.run1=function(){

         }

     }

     Person.name='哈哈哈';

     Person.run2=function(){  静态方法

     }

     var p=new Person();

     Person.run2(); 静态方法的调用

 */

 /*

         function $(element){

             return new Base(element)

         }

         $.get=function(){

         }

         function Base(element){

             this.element=获取dom节点;

             this.css=function(arr,value){

                 this.element.style.arr=value;

             }

         }

         $('#box').css('color','red')

         $.get('url',function(){

         })

 */

     // class Per{

     //     public name:string;

     //     public age:number=20;

     //     //静态属性

     //     static sex="男";

     //     constructor(name:string) {

     //             this.name=name;

     //     }

     //     run(){  /*实例方法*/

     //         alert(`${this.name}在运动`)

     //     }

     //     work(){

     //         alert(`${this.name}在工作`)

     //     }

     //     static print(){  /*静态方法  里面没法直接调用类里面的属性*/

     //         alert('print方法'+Per.sex);

     //     }

     // }

     // // var p=new Per('张三');

     // // p.run();

     // Per.print();

     // alert(Per.sex);

 //多态:父类定义一个方法不去实现，让继承它的子类去实现  每一个子类有不同的表现 

 //多态属于继承

         /*

                 class Animal {

                     name:string;

                     constructor(name:string) {

                         this.name=name;

                     }

                     eat(){   //具体吃什么  不知道   ，  具体吃什么?继承它的子类去实现 ，每一个子类的表现不一样

                         console.log('吃的方法')

                     }

                 }

                 class Dog extends Animal{

                     constructor(name:string){

                         super(name)

                     }

                     eat(){

                         return this.name+'吃粮食'

                     }

                 }

                 class Cat extends Animal{

                     constructor(name:string){

                         super(name)

                     }

                     eat(){

                         return this.name+'吃老鼠'

                     }

                 }

         */

 //typescript中的抽象类：它是提供其他类继承的基类，不能直接被实例化。

 //用abstract关键字定义抽象类和抽象方法，抽象类中的抽象方法不包含具体实现并且必须在派生类中实现。

 // abstract抽象方法只能放在抽象类里面

 // 抽象类和抽象方法用来定义标准 。   标准：Animal 这个类要求它的子类必须包含eat方法

 //标准:

 abstract class Animal{

     public name:string;

     constructor(name:string){

         this.name=name;

     }

     abstract eat():any;  //抽象方法不包含具体实现并且必须在派生类中实现。

     run(){

         console.log('其他方法可以不实现')

     }

 }

 // var a=new Animal() /*错误的写法*/

 class Dog extends Animal{

     //抽象类的子类必须实现抽象类里面的抽象方法

     constructor(name:any){

         super(name)

     }

     eat(){

         console.log(this.name+'吃粮食')

     }

 }

 var d=new Dog('小花花');

 d.eat();

 class Cat extends Animal{

     //抽象类的子类必须实现抽象类里面的抽象方法

     constructor(name:any){

         super(name)

     }

     run(){

     }

     eat(){

         console.log(this.name+'吃老鼠')

     }

 }

 var c=new Cat('小花猫');

 c.eat();