1.类型别名
顾名思义就是给某个类型起别名，之后就可以直接通过这个别名来使用类型
type 别名 = 类型
// 后续直接使用别名即可
例如
/*
* 联合类型语法规则：
* 作用：根据现有的数据类型来定义一个新的数据类型别名，方便编码
* 语法：type 类型别名 = 类型
*
* 注意点：
* 1. 类型别名使用的时候初始值设定要和类型别名中的类型保持一致
* */
// 1. 定义了一个类型别名Length1
type Length1 = number | string
// 2. 使用类型别名定义变量的类型即可
let w1:Length1 = '100%'// ✔️
let w2:Length1 = 100 // ✔️
// let w3:Length1 = true //❌
@Entry
@Component
struct Index {
build() {
Column() {
}
// .backgroundColor()
.height('100%')
.width('100%')
}
}
2.类class
类是用于创建对象的模板，用代码封装数据以处理该数据
语法：
// 类名 首字母大写（规范）
class 类名{
// 属性(字段)
// 方法
// 构造函数
}
// 使用类 实例化对象 基于类 创建对象
const x:类名 = new 类名()
2.1 实例属性
举例:
/*
* 类：作用：根据一个模板动态创建对象
* 类定义语法：
* class 类名 {
* 属性
* 方法
* }
*
* 使用类创建一个对象：
* let obj:类名 = new 类名()
* */
// 需求：创建一个杨幂对象，名字和年龄
// 1. 定义类
class YmPerson {
name: string = '杨幂'//属性（字段）
age: number = 20
}
// 2. 使用类创建对象（实例化）
let ymObj: YmPerson = new YmPerson()
console.log(ymObj.name, ymObj.age)
@Entry
@Component
struct Index {
// sc = new Scroller()
// listsc = new ListScroller()
build() {
Column() {
}
.onClick(() => {
// this.listsc.scrollToItemInGroup(0)
})
.height('100%')
.width('100%')
}
}
2.2 构造函数
class 类{
字段A:类型
字段B:类型
constructor(参数...) {
// 通过 new 实例化的时候 会调用 constructor
// 通过关键字 this 可以获取到实例对象
}
}
const 实例 = new 类()
举例：
/*
构造函数的作用： 一个类中一旦有了显式编写 constructor， 在new 类()的时候是可以传参的
* 这个参数是可以给类中的属性设置初始值，我们可以通过new 时传入不同的数据类决定创建什么阳的对象
*
* ✨✨注意点：
* 1. 如果一个类中没有写constructor构造函数，类本身是有一个默认的没有带参数的构造函数
* 2. 如果想要在new的时候带参数，则我们在定义类的时候，应该要显式编写constructor，参数类型和数量由我们自己定
*
* new 和构造函数的关系
* ① 调new 的时候开辟一个内存空间 -> 写上类中的属性 此时没值
* ② 调用构造函数给属性赋值
* ③ 将创建好的对象返回交给我们定义的变量
* */
// 需求：创建一个杨幂对象，名字和年龄
// 1. 定义类
class Person {
name: string
age: number
// 在构造函数中可以给属性做初始化值操作
constructor(pname: string, page: number) {
// 将 参数赋值给 类中的属性(字段)
this.name = pname
this.age = page
}
}
// 2. 使用类创建对象
let ym: Person = new Person('杨幂', 20)
console.log(ym.name,ym.age)
let lxx:Person = new Person('刘诗诗',19)
console.log(lxx.name,lxx.age)
@Entry
@Component
struct Index {
// sc = new Scroller()
// listsc = new ListScroller()
build() {
Column() {
}
.onClick(() => {
// this.listsc.scrollToItemInGroup(0)
})
.height('100%')
.width('100%')
}
}
2.3 实例方法
类中可以定义方法，并且在内部编写逻辑
class 类名{
方法名(参数...):返回值类型{
// 逻辑...
// 可以通过 this 获取实例对象
}
}
举例：
class isPerson {
dance: string
sing: string
//构建函数给属性进行初始化
constructor(pdance: string, psing: string) {
this.dance = pdance
this.sing = psing
}
//这里进行实例方法1
danced() {
console.log('跳舞')
}
//这里进行实例方法2
singed(sinName: string) {
this.sing = sinName
console.log('唱歌',sinName)
}
}
//实例化
let a: isPerson = new isPerson('杨幂', '征服')
//打印class本身的初始值参数
console.log(a.dance,a.sing)
//这是实例化方法的调用
a.danced()
a.singed('爱的供养')
2.4 静态属性.方法
类还可以添加静态属性、方法，后续访问需要通过 类 来完成。
// 定义
class 类{
static 字段:类型
static 方法(){}
}
// 使用
类.字段
类.方法()
举例：
/*
* 静态属性和方法语法结构：
* class 类名 {
* static 属性名；属性类型
* static 方法名(){}
* }
* */
// 定义一个工具类
class Tools {
// 静态的属性
static PI:number = 3.1415926
static getRandom() {
return Math.random()
}
}
// 使用
console.log(Tools.PI.toString())
console.log(Tools.getRandom().toString())
@Entry
@Component
struct Index {
// sc = new Scroller()
// listsc = new ListScroller()
build() {
Column() {
}
.onClick(() => {
// this.listsc.scrollToItemInGroup(0)
})
.height('100%')
.width('100%')
}
}
说明： 类里面的静态方法，跟一般的类的区别是：当在使用工具类时，不需要使用this. 以及在class里面想要调用PI时，直接用Toos进行调用。 静态类方法不需要进行实例化new
2.5 继承
类可以通过 继承 快速获取另外一个类的 字段 和 方法。 并且还可以扩展属于自己的字段和方法，加强父类没有的能力
class 父类 {
// 字段
// 方法
// 构造函数
}
class 子类 extends 父类{
// 自己的字段（属性）
// 自己的方法
// 可以重写父类方法
}
父类：也可以叫做 基类 、超类 等
子类： 也可以叫做 派生类、继承类 等
举例：
class Person {
//属性（字段）
name: string
age: number
//父类的方法
sayHi() {
console.log(`你好，我叫:${this.name}`)
}
//构建函数，作用是给类进行初始化值
constructor(name: string, age: number) {
this.name = name
this.age = age
}
}
// 第二步：通过 extends 继承父类，此时Student拥有Person的全部属性
class Student extends Person {
// 子类 可以添加自己的属性 和 方法
height: number = 170
//添加自己的方法
sayHello() {
console.log('你好吗~')
}
// 子类可以重写同名字段 、方法
sayHi(): void {
console.log('子类的 sayHi')
}
}
//第三步：进行实例化，因为是继承的Person，使用在这里也是需要进行传参的
const s: Student = new Student('jack', 18)
// 直接可以使用 继承而来的 属性 方法 构造函数
console.log(s.name)
s.sayHi()
2.6 super关键字
子类通过 super 可以访问父类的实例字段、实例方法和构造函数。可以在适当的时候使用 举例：
/*
* super关键字
* 作用：super是在子类中调用父类中的实例属性，实例方法，构造函数之用的
* 语法结构：
* 前置结构，子类 extends 父类
* super的使用：在子类中通过 super可以调用父类的成员
*
* 常用：✨✨通过super类调用父类的构造函数进行属性值的显示调用初始化
* */
// 1. 父类 - 人
class Person {
// 实例属性（字段）
name: string
age: number
// 构造函数
constructor(name: string, age: number) {
this.name = name
this.age = age
}
// 实例方法
sayHi(name2:string) {
console.log('说话',name2)
}
}
// 2. 子类 - 学生 继承了父类人
class Student extends Person {
classesNo: string
constructor(name: string, age: number, classesNo: string) {
super(name, age) // ✨✨super调用父类的构造函数进行父类中的实例属性初始化，只能写在子类的constructor中的第一行
// super()
this.classesNo = classesNo
}
// 由于这个方法父类中没有这个方法，所以是扩展的方法
Len() {
super.sayHi('小三')
// super.name // 获取到的是undefined 请使用this
//console.log(this.name + '学习')
}
}
3. instanceof运算符
用来检测某个对象是否是某个类的实例
class Person {
name: string = ''
}
class Student extends Person {
age: number
constructor(age: number) {
super()
this.age = age
}
}
const s = new Student(10)
console.log('isStudent', s instanceof Student)//反馈结果为true
console.log('isPerson', s instanceof Person)//反馈结果为true
console.log('isArray', [1, 2, 3,] instanceof Array
//反馈结果为true
const arr = [1, 2, 3]
// 等同于
const arr2 = new Array(1, 2, 3)
结果：
4.typeof运算符
通过typeof 运算符来获取类型，他返回的是一个类型字符串 举例：
// 前面 5 个可以正常获取到类型
console.log(typeof 123) // number
console.log(typeof '123') // string
console.log(typeof false) // boolean
console.log(typeof undefined) // undefined
function func() {
}
console.log(typeof func) // function
class Person {
name: string = 'jack'
}
// 对象 数组 null 获取到的都是 object
// 后续可以结合 instanceof 进行精确判断
const p: Person = new Person()
console.log(typeof null) // object
console.log(typeof [1, 2, 3]) // object
console.log(typeof p) // object
5.修饰符
readonly 只读 属性，不能进行其他的操作
private 私有 属性、方法 类内部可以访问，只能父类内部自己使用
protect 保护 属性、方法 类及子类可以访问，但是只能在子类的{}中使用，不能在外面使用，如不能在{}外面进行.出来
public 公共 属性、方法 无限制
6.剩余和展开
在不同的情况下有不同的效果，分别是 展开数组 和 剩余参数
//作用1：
function sum(numA:number,numB:number,...theArgs:number[]) {
let total = numA+numB
for (const arg of theArgs) {
total += arg;
}
return total;
}
//在进行传参数的时候，利用...数组名：类型[]
console.log(sum(1, 2, 3).toString()) // 6
console.log(sum(1, 2, 3, 4).toString()) // 10
//注意：使用...只能是数组类型
//作用2：可以将一个数组快速传入一个空数组
let a:string[] = ['a', 'b' , 'c' , 'd']
let b:string[] = []
b.push(...a)
console.log(b.toString())
//作用3：将两个数组快速进行合并
const numArr1: number[] = [1, 2, 3, 4]
const numArr2: number[] = [5, 6, 7]
// 合并到一起
const totalArr: number[] = [...numArr1, ...numArr2]
console.log('',totalArr)
@Entry
@Component
struct Index {
build() {
Column() {
}.backgroundColor(Color.Pink)
.width('100%')
.height('100%')
}
}
