关于鸿蒙开发中Class类的介绍

类是用于 创建对象 模板。同时类声明也会引入一个 新类型，可定义其 实例属性、方法和构造函数。

语法

// 类名 首字母大写（规范）
class 类名 {
    // 1.实例属性（字段）
    // 2.构造函数
    // 3.方法
}

// 使用类 实例化对象 基于类 创建对象
const p:类名 = new 类名()

Class类 实例属性

通过实例属性（字段），可以保存各种类型的数据。

语法

// 类
class 类名 {
    // 字段名、类型、初始值
    字段名1：类型 = 'xxx'
    // 可选字段可以不设置初始值
    字段名2？：类型
}

// 可选字段在使用时需要配合 可选链操作符 避免出错
const p:类名 = new 类名()
p.字段名1
p?.字段名2

实例

class Person {
    name: string = 'tony'
    food?: string
}

const p = new Person()
p.name = 'tom'

console.log(p.name) // tom
console.log('字符串', p.food?.length) // 字符串 undefined

Class类 构造函数

不同实例，将来需要有 不同的字段初始值，就需要通过构造函数实现。

语法

class 类 {
  字段A：类型
  字段B：类型

  constructor(参数...) {
  //   通过 new 实例化的时候，会调用 constructor
  // 通过关键字 this 可以获取到实例对象
  this.字段名A = 参数
  }
}

const 实例1 = new 类(参数...)
const 实例2 = new 类(参数...)

实例

class Food {
  name: string
  price: number

  constructor(name: string, price: number) {
    this.name = name
    this.price = price
  }
}

const f1 = new Food('西红柿炒鸡蛋', 15)
const f2 = new Food('土豆顿鸡块', 24)

Class类 定义方法

类中可以定义 方法，并且在内部编写逻辑。

语法

class 类名 {
  方法名(参数...):返回值类型 {
//     代码逻辑
//   可以通过 this 获取实例对象
}

实例

class Person {
  name: string

  constructor(name: string) {
    this.name = name
  }

  sayHi(name: string) {
    console.log(`你好${name}，我是：${this.name}`)
  }
}

const p: Person = new Person('jack')
p.sayHi('rose') // 你好rose，我是：jack

静态属性和静态方法

类还可以添加 静态属性、方法，后续访问需要通过 类 来完成。

语法

// 定义
class 类{
static 字段:类型
 static 方法(){}
}
// 使用
类.字段
类.方法()

实例

// 静态属性和方法
class Robot {
// 如果不设置值, 默认是 undefined
static version: string = '10.12'

// 工具方法
 static getRandomNumber () {
  return Math.random()
 }
}
Robot.version
Robot.getRandomNumber()

继承 extends 和 super关键字

类可以通过 继承 快速获取另外一个类的 字段 和 方法。

语法

class 父类 {
    // 字段
    // 方法
    // 构造函数
}

class 子类 extends 父类 {
    // 自己的字段（属性）
    // 自己的方法
    // 可以重写父类方法
}

子类通过 super 可以访问父类的实例字段、实例方法和构造函数。 

class 父类 {
    func() {}
}

class 子类 extends 父类 {
    constructor() {
        super() // 调用父类构造函数
    }
    方法() {
        super.方法() // 调用父类方法
    }
}

实例

class Person {
  name: string
  age: number

  constructor(name: string, age: number) {
    this.name = name
    this.age = age
  }

  sayHi() {
    console.log(`大家好，我是：${this.name}`)
  }
}

class Student extends Person {
  // 子类自己的属性
  grade: string

  // 子类的构造函数
  constructor(name: string, age: number, grade: string) {
    // 父类中的构造函数，此时需要我们手动调用
    // 注意：super的调用要写在自己属性初始化的前边
    super(name, age)
    // 完成自己属性的初始化
    this.grade = grade
  }

  // 子类自己的方法
  study(subject: string) {
    console.log(`我正在学习，${subject}`)
  }

  // 子类中想要重写父类中的方法，只需提供同名的方法即可
  sayHi(): void {
    super.sayHi() // 调用父类的方法
    console.log('hello') // 扩展了自己的特性
  }
}

const xiaoming: Student = new Student('小明', 10, '三年级')
console.log(xiaoming.grade) // 三年级
/*
 * 大家好，我是：小明
 * hello
 * */
xiaoming.sayHi() 
xiaoming.study('鸿蒙') // 我正在学习，鸿蒙

instanceof检测是否实例

instanceof 运算符可以用来检测某个对象是否是某个类的实例。

语法

实例对象 instanceof Class

typeof 表达式

typeof 仅能用于判断简单类型，复杂类型需要instanceof判断 

interface Img {
  url: string,
  num: number
}

const arr: number[] = [1, 2, 3]
const obj: Img = {
  url: '12',
  num: 2
}

class Person {}
class Student {}

let p:Person = new Person()
let s:Student = new Student()

console.log(typeof 123) // number
console.log(typeof 'abc') // string
console.log(typeof true) // boolean
console.log(typeof arr) // object
console.log(typeof obj) // object
console.log(typeof p)   // object
console.log(typeof s)   // object

实例

class Person {
  name: string
  age: number

  constructor(name: string, age: number) {
    this.name = name
    this.age = age
  }
}

class Student extends Person {}

const s: Student = new Student('小明', 3)
console.log('判断结果：', s instanceof Student) // 判断结果： true
console.log('判断结果：', s instanceof Person) // 判断结果： true

修饰符

类的 方法 和 属性 可以通过修饰符来 限制 访问。

修饰符包括：readonly、private、protected和public。省略不写默认为public。

修饰符名	作用	访问限制
readonly	只读	无限制
private	私有	类内部可以访问
protected	保护	类及其子类可以访问
public	公共	无限制

readonly

只可以取值，无法修改

class 类 {
    readonly 属性：类型
}

class Cat {
  name: string
  age: number
  readonly legs: number = 4

  constructor(name: string, age: number) {
    this.name = name
    this.age = age
  }
}

let c = new Cat('花花', 1)
c.name = '涂涂'
c.legs = 5
console.log(c.name) // 涂涂

 

private

private修饰的成员不能在声明该成员的类之外访问，包括子类。

class 类 {
    private 属性：类型
    private 方法(){}
}

class Person {
  private name: string = ''
  private age: number = 18

  sayHi() {
    //   内部可以访问
    console.log(`你好，我叫${this.name}`)
  }
}

class Student extends Person {
  sayHello() {
    //   无法访问，报错
    // console.log(`你好，我叫${super.name}`)
  }
}

const p = new Person()
// p.name // 无法访问报错
p.sayHi() // 你好，我叫

protected

protected修饰符的作用与private修饰符非常相似

不同的是protected修饰符的成员允许在 派生类（子类）中访问

class 类 {
    protected 属性：类型
    protected 方法(){}
}

 

class Person {
  protected name: string = ''
  protected age: number = 18

  sayHi() {
    //   内部可以访问
    console.log(`你好，我叫${this.name}`)
  }
}

class Student extends Person {
  sayHello() {
    //   可以访问到父类的protected属性
    console.log(`你好，我叫${super.name}`)
  }
}

const p = new Person()
p.name // 无法访问报错
p.sayHi() // 你好，我叫

public【默认】

public修饰的类成员（字段、方法、构造函数）在程序的任何可访问该类的地方都是可见的

class 类 {
    public 属性：类型
    public 方法(){}
}

class Person {
  public name: string = ''
  public age: number = 18

  sayHi() {
    //   内部可以访问
    console.log(`你好，我叫${this.name}`)
  }
}

class Student extends Person {
  sayHello() {
    //   可以访问到父类的public属性
    console.log(`你好，我叫${super.name}`)
  }
}

const p = new Person()
p.name
p.sayHi() // 你好，我叫