typescript靜態屬性,靜態方法,抽象類,多態

/*
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();