Typescript 中的类

1. ts 中类的定义

  es5：

function Person(name) {
    this.name = name;
    this.run = function() {
        console.log(this.name)
    }
}
var p = new Person('张三')
p.run()

1.1  ts 中类的定义

class Person {
    name:string; // 属性 前面省略了public 关键词
    constructor(n:string) {
        this.name = n;
    }
    getName():string {
        alert(this.name)
        return this.name;
    }
    setName(name:string):void {
        this.name = name;
    }
}
var p = new Person('赵四')
p.getName()
p.setName('王麻子')
p.getName()

1.2  ts 中类的继承

class Person {
    name:string;
    constructor(name:string) {
        this.name = name;
    }
    run():string {
        return `${this.name}在运动`
    }
}
class Women extends Person {
    constructor(name:string) {
        super(name);
    }
    run():string {
        return `${this.name}在运动 - 子类`
    }
    work():string {
        return `${this.name}在工作`
    }
}
var p = new Women('李斯')
alert(p.run())
alert(p.work())

1.3  类的修饰符

类里面的修饰符 typescript 里面定义属性时提供了 三种修饰符：

 public:        公有    在类里面、子类、类外面都可以访问

 protected:  保护类型   在类里面、子类里面可以访问，在类外面无法访问

 private:       私有    在类里面可以访问，子类、类外面都无法访问

 注：不加修饰符，默认是 public

 // 类外部访问公有属性
 class Person {
     public name:string;
     constructor(name:string) {
        this.name = name;
     }
     run():string {
         return `${this.name}在运动`
     }
 }
 var p = new Person('哈哈哈');
 alert(p.name)

 

class Person {
    protected name:string;
    constructor(name:string) {
        this.name = name;
    }
    run():string {
        return `${this.name}在运动`
    }
}
class Web extends Person {
    constructor(name:string) {
        super(name);
    }
    work() {
        alert(`${this.name}在工作`)
    }
}
var w = new Web('许三多')
w.work()

  var p = new Person('张三')

  p.name // 无法访问

 

 1.4 静态属性   静态方法

  class Person {

    public name:string

    static age:number = 20;

    constructor(name:string) {

        this.name = name;

    }

    run() { // 实例方法

        alert(`${this.name}在跑步`)

    }

    work() {

        alert(`${this.name}在搬砖`)

    }

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

        alert(`${this.name}在打印`)  // 错误使用，类型“typeof Person”上不存在属性“name”。

        alert(`${Person.age}在打印`) // 正确使用

    }

  }

  var p = new Person('许三多');

  Person.print();

1.5 多态

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

多态属于继承。

class Animal {
    name:string;
    constructor(name:string) {
        this.name = name;
    }
    eat() {
        console.log('吃东西')
    }
}
class Dog extends Animal {
    constructor(name:string) {
        super(name);
    }
    eat() {
        console.log(this.name + '吃狗粮')
    }
}
class Cat extends Animal {
    constructor(name:string) {
        super(name);
    }
    eat() {
        console.log(this.name + '吃猫粮')
    }
}
var dog = new Dog('小狗')
dog.eat()
var cat = new Cat('小猫')
cat.eat()

1.6 抽象类

// ts 中的抽象类，它是提供其他类继承的基类，不能直接被实例化。
// 用 abstract 关键字定义抽象类和抽象方法，抽象类中的抽象方法不包含具体实现并且必须在派生类中实现。
// abstract 抽象方法只能放在抽象类里面
// 抽象类和抽象方法用来定义标准。标准：Animal 要求它的子类必须包含 eat 方法

  

  abstract class Animal {

    name:string;

    constructor(name:string) {

        this.name = name;

    }

    abstract eat():any;

  }

  // 抽象类的子类必须实现抽象类的抽象方法，其他方法可以不实现

  class Dog extends Animal {

    constructor(name:string) {

        super(name);

    }

    eat() {

        alert(this.name + '吃狗粮')

    }

  }

  let dog = new Dog('萨摩耶')

  dog.eat()