typescript——4、类

ts中类的定义

class Person{
    name:string;

    constructor(n:string){
        this.name = n
    }
    getName():string{
        return this.name
    }
    setName(name:string):void{
        this.name = name
    }
}

var p = new Person("张三")
p.getName()
p.setName("李四")

ts中实现继承

class Person{
    name:string;

    constructor(name:string){
        this.name = name
    }
    run():string{
        return `${this.name}运行`
    }
}

class web extends Person{
    constructor(name:string){
        super(name) //初始化父类的构造函数
    }
}

类里面的修饰符

typescript里面定义属性的时候给我们提供了三种修饰符

• public：公有—— 在类里面 子类 类外面都可以访问
• protected:保护类型——在类里面、子类里可以访问，在类外面没法访问
• private：私有——在类里面可以访问，在子类和类外面都无法访问
  属性如果不加修饰符，默认就是公有（public）

class Person{
    public name:string;
    protected age:number;
    private money:number;
    constructor(name:string,age:number,money:number){
        this.name = name
        this.age = age
        this.money  = money
    }
    run():string{
        return `${this.name}运行`
    }
}

class web extends Person{
    constructor(name:string,age:number,money:number){
        super(name,age,money) //初始化父类的构造函数
    }
    run():string{
        return `${this.age}运行,子类`
    }
}

// 类外部访问公有属性
var p = new Person("张三",20,3000)
var w = new web("李四",19,4000)
alert(p.run())
alert(w.run())
alert(w.age)//报错

静态属性和静态方法

class Person{
    name:string
    static age:number
    constructor(name:string){
        this.name = name
    }
    // 静态方法里面没法直接调用类里面的属性
    static print(){
        alert('111')
        // alert(this.name)
        alert(Person.age)
    }
}
Person.print()
alert(Person.age)

多态

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

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抽象方法智能放在抽象类里面
• 抽象类和抽象方法用来定义标准

abstract class  Animal {
    public name:string
    constructor(name:string){
        this.name = name
    }
   abstract eat():any;
}

class Dog extends Animal{
    constructor(name:string){
        super(name)
    }
    // 抽象类的子类必须实现抽象类里面的抽象方法
    eat(){
        console.log(this.name+'吃粮食')
    }
}
var d = new Dog("小花")
d.eat()

class Cat extends Animal{
    constructor(name:string){
        super(name)
    }
    eat() {
        console.log(this.name+'吃老鼠')
    }
 
}
var cat = new Cat("小花")
cat.eat()