6、类的使用

类的成员修饰符

在TypeScript中，类的属性和方法支持三种修饰符：

public、private、protected

• public 修饰的是在任何地方可见、公有的属性或方法，默认编写的属性就是public的
• private 修饰的是仅在同一类中可见、私有的属性或方法
• protected 修饰的是仅在类自身及子类中可见、受保护的属性或方法
• public是默认的修饰符，也是可以直接访问的

class Person{
    // 默认为public
    name:string = 'xxx'
}
let p = new Person
console.log(p.name); //xxx
class Person2 {
  // private 类中才可以访问到
  private name: string = 'xxx';
  getname() {
    return this.name;
  }
}
let p2 = new Person2();
// console.log(p.name); //私有属性，类中才可以访问到
console.log(p2.getname()); //xxx
class Person1 {
  // protected 受保护 类中及子类在才可以访问
  protected name1: string = 'xxx';
  getname() {
    return this.name1;
  }
}
let p1 = new Person1();
// console.log(p1.name); //受保护 类中和子类在才可以访问
console.log(p1.getname());//xxx
class Stu extends Person1 {
  get() {
    return this.name1;
  }
}
let s1 = new Stu();
console.log(s1.get()); //xxx

只读属性readonly

如果有一个属性我们不希望外界可以任意的修改，只希望确定值后直接使用，那么可以使用readonly

class Person {
  readonly name: string = 'yy';
  age: number = 20;
  readonly friend?: Person;
  //只读属性可以在constructor中修改
  constructor(name: string, friend?: Person) {
    this.name = name;
    this.friend = friend;
  }
}
let p = new Person('xxxx');
console.log(p.name); //xxxx
// p.name = 'mmmm' // 报错，因为只读不能修改
let p2 = new Person('nnn', new Person('kkk'));
// p2.friend = {'c'} // 报错，因为只读不能修改
// 可以这样修改
console.log(p2.friend);
if(p2.friend){
    p2.friend.age = 30;
    console.log(p2.friend.age); //30
}
export {};

getters/setters

前面一些私有属性我们是不能直接访问的，或者某些属性我们想要监听它的获取(getter)和设置(setter)的过程， 这个时候我们可以使用存取器

class Person {
  private _name: string = ''
  set name(newName) {
    this._name = newName;
  }
  get name() {
    return this._name;
  }
}
let p = new Person();
p.name = 'ccc';
console.log(p.name); //ccc
export {};

静态成员

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

在TypeScript中通过关键字static来定义：

class Person {
  static time: string = '10:10';
  static get() {
    return this.time;
  }
}
console.log(Person.time); //10:10
console.log(Person.get()); //10:10
export {};

抽象类abstract

继承是多态使用的前提。

所以在定义很多通用的调用接口时, 我们通常会让调用者传入父类，通过多态来实现更加灵活的调用方式

但是，父类本身可能并不需要对某些方法进行具体的实现，所以父类中定义的方法,，我们可以定义为抽象方法

什么是抽象方法?

• 在TypeScript中没有具体实现的方法(没有方法体)，就是抽象方法。
• 抽象方法，必须存在于抽象类中
• 抽象类是使用abstract声明的类

• 抽象类有如下的特点：

  • 抽象类是不能被实例的话（也就是不能通过new创建）
  • 抽象方法必须被子类实现，否则该类必须是一个抽象类

function makeArea(shape: Shape) {
  return shape.getArea();
}
abstract class Shape {
  abstract getArea() 
}
class Jx extends Shape {
  width: number;
  length: number;
  constructor(width: number, length: number) {
    super();
    this.width = width;
    this.length = length;
  }
  getArea(){
      return this.width * this.length
  }
}
let jx = new Jx(10,20)
console.log(makeArea(jx)); //200

类的类型

类本身也是可以作为一种数据类型的

class Person {
  name: string;
  eat() {}
}
//根据类型推导 p的类型为Person
let p = new Person();
let p1: Person = {
  name: 'xxx',
  eat: function () {},
};