欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

TypeScript中类的使用

程序员文章站 2022-07-03 20:52:48
...

类的定义

  • 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)