04Typescript中的类

类描述了所创建的对象共同的属性和方法。

ts 中定义类

class Person {
  name: string; // 属性  前面省略了public关键词

  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()); // 张三
p.setName("李四");
console.log(p.getName()); // 李四

ts 中实现继承

class Person {
  name: string;
  constructor(name: string) {
    this.name = name;
  }
  run(): string {
    return `${this.name}在运动`;
  }
}

var p = new Person("杜甫");
console.log(p.run());

class Web extends Person {
  constructor(name: string) {
    super(name); ///*初始化父类的构造函数*/
  }
}
var w = new Web("白居易");
console.log(w.run()); // 白居易在运动

类里面的修饰符

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

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

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

class Person {
  public name: string; // 属性如果不加修饰符 默认就是 公有 （public）
  protected age: number; //保护类型
  private sex: string; // 私有类型
  constructor(name: string, age: number, sex: string) {
    this.name = name;
    this.age = age;
    this.sex = sex;
  }
  run(): string {
    return `${this.name}性别${this.sex},今年${this.age},正在运动`;
  }
}

var p = new Person("杜甫", 18, "男");
console.log(p.name); // 正确
// console.log(p.age); // 报错->属性“age”受保护，只能在类“Person”及其子类中访问。
// console.log(p.sex); // 报错->属性“sex”为私有属性，只能在类“Person”及其子类中访问。
console.log(p.run());

class Web extends Person {
  constructor(name: string, age: number, sex: string) {
    super(name, age, sex); ///*初始化父类的构造函数*/
  }
  run(): string {
    // console.log(this.sex); //报错 属性“sex”为私有属性，只能在类“Person”中访问。
    return `${this.name}今年${this.age},在跳舞`; // 正确
  }
}
var w = new Web("貂蝉", 88, "女");
console.log(w.run());

静态属性和静态方法

es5 中的定义:

function Person(name) {
  this.name = name; // 实例属性

  this.run = function () {
    //实例方法
    console.log(this.name);
  };
}

Person.name = "哈哈哈"; // 静态属性
Person.run2 = function () {
  // 静态方法
  console.log("静态方法");
};

var p = new Person("张三");

p.run(); // 实例方法的调用
Person.run2(); // 静态方法的调用
Person.name; // 静态属性的调用

ts 中的定义:

class Person {
  public name: string;

  static sex = "男"; // 静态属性
  constructor(name: string) {
    this.name = name;
  }

  run() {
    /*实例方法*/
    console.log(`${this.name}在运动`);
  }
  work() {
    /*实例方法*/
    console.log(`${this.name}在工作`);
  }
  static print() {
    /*静态方法*/
    console.log("print方法" + Person.sex);
    // 里面没法直接调用类里面的属性
    // console.log(this.name+'print') // 报错
  }
}

var p = new Person("王五");
p.run();
p.work();
Person.print();
console.log(Person.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 + "吃老鼠";
  }
}

var dog = new Dog("heily");
console.log(dog.eat()); // heily吃粮食
var cat = new Cat("daimo");
console.log(cat.eat()); // daimo吃老鼠

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