typescript中的类，继承，修饰符，静态属性&静态方法，抽象类&多态

TypeScript 是 JavaScript 的一个超集，支持 ECMAScript 6 标准（ES6 教程）。

适用开发大型应用，它可以编译成纯 JavaScript，TypeScript 是一种给 JavaScript 添加特性的语言扩展；

一、typescript中定义类：class

class Person{
    name: string;
    constructor(name: string){
        this.name = name;
    }

    getName():string{
       return this.name 
    }

    setName(name: string): void{
        this.name = name
    }
}

var p = new Person('张三');
console.log(p.getName())

二、typescript中类的继承：extends，super

//*** extends 来声明类的继承关系
class Web extends Person{
    constructor(name: string){
        super(name)    //调用父类的构造函数或方法
    }

    work(){
        return `${this.name}-在工作！`
    }
}

var w = new Web('老刘');
console.log(w.getName());

三、typescript中的修饰符：

       public :公有 在当前类里面、 子类 、类外面都可以访问
　　protected：保护类型 在当前类里面、子类里面可以访问 ，在类外部没法访问
　　private ：私有 在当前类里面可以访问，子类、类外部都没法访问

　　***  属性如果不加修饰符 默认就是 公有 （public）

class Person{
    public name:string;   
    protected sex:string;   //***  保护属性
    private age:number;      //*** 私有属性
    constructor(name:string,age:number,sex:string,){
        this.name = name;
        this.age = age;
        this.sex = sex;
    }
    run(){
        return `我是${this.name},${this.sex},我今年${this.age}岁了`
    }
}

class Children extends Person{
    constructor(name:string,age:number,sex:string){
        super(name,age,sex)
    }
    speak(){
        console.log(this.name);   //正确  公有可以在本类，子类，类外部访问
        console.log(this.sex);   //正确   保护类型可以在子类中使用
        // console.log(this.age);   //报错   私有属性只能在它本类中使用
    }
}
var p=new Person("小舞", 7, "女");


console.log(p.name);    //正确，公有可以在本类，子类，类外部访问
// console.log(p.sex);    //报错，受保护类型只能在本类或者子类中访问
// console.log(p.age);   //报错，私有的属性不能再类外部访问

var c=new Children("唐三", 8, "男");
console.log(c.name);     
//console.log(c.age);    //报错，私有的属性不能再类外部访问

四、typescript中的静态属性和静态方法：static

//*** static   在静态方法中没办法调用类的属性，可以调用类里面的静态属性
class Person{
    public name: string;
    static language = '说中文';    //*** 静态属性
    constructor(name: string){
        this.name = name;
    }

    getName():string{
       return this.name 
    }

    setName(name: string): void{
        this.name = name
    }

    static speak():any{    //*** 静态方法
        // console.log(`${this.name}`)   //*** 报错   静态方法 里面没法直接调用类里面的属性
        console.log(`${this.language}`)    //可以访问
    }
}

var p = new Person('张三');
console.log(p.getName())
Person.speak();

五、typescript的抽象类：abstract

//***  typescript中的抽象类，它是提供其他类继承的基类，不能直接被实例化
//***  abstract关键字来定义抽象类和抽象方法，用来定义标准，为子类提供基类，抽象方法只能放在抽象类里面
//***  抽象类的子类必须实现 抽象类里面的抽象方法

abstract class Person{ 
    public name:string;
    constructor(name:string){
        this.name=name;
    }

    abstract speak():any;    //抽象方法不包含具体实现
}

// var a=new Person()   //***错误  不能直接被实例化

class English extends Person{
    constructor(name:any){
        super(name)
    }

    speak(){           //*** 实现抽象类里面的方法
        console.log(this.name+'说英语')
    }
}

var p1=new English('Jhon');
p1.speak();

class Chinese extends Person{
    constructor(name:any){
        super(name)
    }

    speak(){           //*** 现抽象类里面的方法
        console.log(this.name+'说中文')
    }
}

var p2=new Chinese('李雷');
p2.speak();

六、typescript中的多态：

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

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 + '吃老鼠'
    }
}

var dog = new Dog('大黄');
console.log(dog.eat());