类和对象

类和对象（实例）

演示代码如下：

class Person {
  name: string //属性

  constructor(name: string) { //构造函数
    this.name = name
  }

  show(): void { //方法，注意前面没有 function 关键字
    console.log("姓名：" + this.name)
  }
}

let obj = new Person("小王")
obj.name = "老王" //访问属性
obj.show() //访问方法

• 对象其实就是包含一组键值对的实例，这里的值可以是标量、函数、数组、对象等。

注意：跟JAVA不同，在HarmonyOS ArkTS开发中，创建类的属性之后必须要使用构造函数进行赋值，否则报错。因为ArkTS是一种类型严格的编程语言，它要求所有变量在使用前必须被初始化。所以每个类的属性都需要在声明时或在构造函数中被初始化。

成员权限

• 类中的成员有 公有（public）、私有（private）和保护（protected）三种保护权限，默认是公有（public）权限。

演示代码如下：

class OtherPerson {
  private name: string //私有属性
  protected id: string //保护属性

  constructor(name: string, id: string) {
    this.name = name
    this.id = id
  }
  public show(): void { //公有方法，public可省略
    console.log("姓名：" + this.name)
  }
}

• 公有权限的成员在类内和类外都能进行访问。
• 保护权限的成员只能在类内和子类进行访问。
• 私有权限的成员可以在类内进行访问。

static关键字

• static关键字用于定义类的成员（属性和方法）为静态的，静态成员属于类本身的，直接通过类名调用。

演示代码如下：

class Car {
  static num: number //静态成员
  public static disp(): void {
    console.log("num值为：" + Car.num)
  }
}

Car.num = 12 //初始化静态变量
Car.disp() //调用静态方法

类的继承

• 类的继承使用的关键字是extends，在TS中只支持单继承。
• 继承可以重写方法，可以通过super访问父类中的成员。

演示代码如下：

class Student extends Person {
  major: string //增加新属性

  constructor(n: string, m: string) { //构造函数
    super(n)  //调用父类构造函数
    this.major = m
  }

  show(): void {  //重写方法
    super.show()  //调用父类中的函数
    console.log("专业：" + this.major)
  }
}

let obj = new Student("张三", "软件工程")
obj.show()

接口

• 接口是一系列抽象的声明，定义接口的基本语法如下：

interface 接口名{
    //...
}

• 接口的使用非常灵活，它可以作为类型限制数据。

演示代码如下：

interface LabelType {
  tag: string
}

function printLabel(label: LabelType) {
  //这里参数label要符合LabelType接口规则
  //参数必须包含一个tag属性
  console.log(label.tag)
}

let obj: LabelType = { tag: "HarmonyOS" }
printLabel(obj)

• 接口可以继承，允许接口继承一个或多个接口，继承关键字是extends，多继承时父接口以逗号分隔。

接口继承接口演示代码如下：

interface T1 { a: number }
interface T2 { b: number }

interface I extends T1, T2 {}

let Iobj: I = { a: 100, b: 200 }
console.log("a:" + Iobj.a + " b:" + Iobj.b) //输出a:100 b:200

• 类可以实现接口，实现接口的关键字是implements。

interface IRun { //定义接口
  n: number
  run(): void
}

class Run implements IRun { //实现接口
  n: number

  run(): void {
    let i = 0
    for (i; i < this.n; i++) {
      console.log("i的值：" + i)
    }
  }

  constructor(n: number) { //构造函数
    this.n = n
  }
}

let obj = new Run(3) //创建对象
obj.run()
/*输出结果：
i的值：0
i的值：1
i的值：2
*/

泛型

泛型函数

• 一个函数在定义时使用类型参数，则该函数称为泛型函数。

function find<T>(array:T[],value:T) {
  //T为类型参数，可以有多个类型参数
  for(let v of array){
    if(v === value)
      return true
  }
  return false
}

• 在定义一个类时，如果使用一个或多个类型参数，则该类被称为泛型类。

class KVPair<K, V> {
  key: K
  value: V

  constructor(key: K, value: V) {
    this.key = key
    this.value = value
  }
}

let kv1 = new KVPair<string, number>("张三", 99)
console.log(kv1.key + " " + kv1.value)  //输出 张三 99