TypeScript中类的使用

Posted 2021-08-19 忘忘碎斌bin

TypeScript中的类

• 类的定义
• 类的继承
• 类的多态
• 类的成员修饰符
• 类的只读属性
• 类的访问器
• 类的静态成员
• 类的抽象类和方法
• 类类型

类的定义

• TypeScript类里面的属性必须先声明，可以先赋值、也可以在constructor内赋值。
• 默认条件下：在属性申明时，不需要赋值。但在 tsconfig.json内的 “strictPropertyInitialization”: true 条件下必须赋值，若不想赋值那么在声明的属性后加 !。

class Person {
  name:string 
  age:number
  constructor(name:string,age:number){
    this.name = name;
    this.age = age
  }
  eatting(){
    console.log("Person eatting");
  }
}
console.log(new Person('fzb',21));
// Person { name: 'fzb', age: 21 }

类的继承

• 通过super关键字可以调用父类的方法

class Student extends Person{
  sno:number
  constructor(name:string,age:number,sno:number){
    super(name,age);
    this.sno = sno;
  }
  eatting(){
    super.eatting()
    console.log('student eatting');
  }
  learning(){
    console.log('student learning');
  }
}
const student :Student = new Student('fzb',21,240);
console.log(student);// Student { name: 'fzb', age: 21, sno: 240 }
student.eatting();
// Person eatting
// student eatting
student.learning();// student learning

类的多态

• 父类的类型可以传入子类对象。

const lists : Person[] = [];
lists.push(new Student('fzb',21,240),new Student('gj',21,231),new Student('zzw',21,205));
lists.forEach(item => {
  item.eatting();
})

类的成员修饰符

• public：在代码中，不加修饰符，默认就是public，public修饰的属性或方法可以在自己的类里面使用，也可以在子类内使用，外部也可以直接通过 . 的方式调用。

const student = new Student('fzb',21,240);
console.log(student.sno);  // 240

• protected：protected修饰的属性或方法可以在自己的类里面使用，也可以在子类内使用，但外部不可以直接通过 . 的方式调用。
• 通过内部暴露的方法来获取对应的值。

class Person {
  name:string 
  protected age:number
   ..... 
    getAge(){
    return this.age
  }
}
const person = new Person('fzb',21);
console.log(person.age); // 报错
console.log(person.getAge()); // 21

• private：private修饰的属性或方法只可以在自己的类里面使用。通过内部暴露的方法来获取对应的值。

类的只读属性

只读属性: readonly，只可以在构造器内进行赋值。

• 只读属性和const差不多，本身的指针是不能改变的，内容其实可以变。

class Student extends Person{
  readonly sno:number
  constructor(name:string,age:number,sno:number){
    super(name,age);
    this.sno = sno;
  }
  ......
}

类的访问器

类的访问器 ：setter和getter 一般是和private一起使用，private不能通过 .的方法进行获值和取值。通过访问器就可以了。

class Person {
  private _name:string 
  private age:number
  constructor(name:string,age:number){
    this._name = name;
    this.age = age
  }
  set name(newValue:string){
    this._name = newValue;
  }
  get name(){
    return this._name
  }
}
const person = new Person('fzb',21);
console.log(person.name); // fzb

类的静态成员

前面在类中定义的成员和方法都属于对象级别的, 在开发中, 有时候也需要定义类级别的成员和方法。

class Person {
  static nationality:string = '中国';
  static say(){
    console.log('我是'+this.nationality+'人'); 
  }
}
console.log(Person.nationality); // 中国
Person.say(); // 我是中国人

类的抽象类和方法

在父类里声明出方法，在子类里进行实现。

• 含有抽象方法一定是抽象类，抽象类不一定全部是抽象方法。
• 若子类不是抽象类，那么要在子类里实现抽象方法。
• 抽象类不能实例化

abstract class  Person {
  abstract say():void;
  eatting(){
    console.log("我要吃东西");
  }
}
class Student extends Person{
  say(){
    console.log('我是学生');
  }
}
class Teacher extends Person{
  say(){
    console.log('我是老师');
  }
}

类类型

平常类是用new 创建一个实例，但是一个对象的类型是类也是可以的。

class Person {
  name:string
  constructor(name:string){
    this.name = name
  }
}
function printName(person:Person){
  console.log(person.name); 
}
const myName:Person = {
  name:'fzb'
}
printName(myName)