笔记 HarmonyOS：ArkTS-回顾
ArkTS-回顾
·
1.声明式UI开发：
2.组件语法
容器组件(参数) {
内容
}
.属性1()
.属性2()
.属性...()
普通组件(参数)
.属性1()
.属性2()
.属性...()3.typeof运算符
function func(){
numb:Number
}
class Person{
name:string='Tom'
}
@Entry
@Component
struct TypeofPage {
onPageShow() {
console.log(typeof 123)//number
console.log(typeof '123')//string
console.log(typeof false)//boolean
console.log(typeof undefined)//undefined
console.log(typeof func())// function
console.log(typeof Person)// function
}
build() {
}
}4.类
类是用于创建对象的模板。他们用代码封装数据以处理该数据。同时类声明也会引入一个新类型，并定义其字段、方法和构造函数。
// 类名 首字母大写（规范）
class 类名{
// 字段
// 方法
// 构造函数
}
// 使用类 实例化对象 基于类 创建对象
const x:类名 = new 类名()4.1实例属性
可以通过实例属性（字段）来保存各种类型的数据。
// 类
class 类名{
// 字段名+类型+初始值
字段名:类型='xxx'
// 可选字段可以不设置初始值
字段名?:类型
}
// 可选字段在使用时需要配合，可选链操作符避免出错代码：
class Person {
name: string = '一只小风华~'
aibo?: string
}
const p = new Person()
p.name = '一只小风华~'
console.log(p.name)
console.log('', p.aibo?.length)4.2构造函数
class 类{
字段A:类型
字段B:类型
constructor(参数...) {
// 通过 new 实例化的时候 会调用 constructor
// 通过关键字 this 可以获取到实例对象
}
}
const 实例 = new 类()代码：
interface IFood {
name: string
price: number
}
class Food {
name: string
price: number
// constructor(name:string,price:number) {
// this.name=name
// this.price = price
// }
constructor(value: IFood) {
this.name = value.name
this.price = value.price
}
}
// const f = new Food('西兰花炒蛋', 15)
const f = new Food({ name: '花菜炒蛋', price: 10 })4.3实例方法
类中可以定义方法，并且在内部编写逻辑。
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')4.4静态属性、方法
类可以添加静态属性、方法、后续访问需要通过类来完成。
// 定义
class 类{
static 字段:类型
static 方法(){}
}
// 使用
类.字段
类.方法()代码：
class Person{
static staticField:string ='静态字段'
static staticMethod(){
console.log('静态方法')
}
}
Person.staticField
Person.staticMethod()4.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 继承父类
class Student extends Person {
// 子类 可以添加自己的属性 和 字段
height: number = 170
sayHello() {
console.log('你好吗~')
}
// 子类可以重写同名字段 、方法
sayHi(): void {
console.log('子类的 sayHi')
}
}
const s: Student = new Student('jack', 18)
// 直接可以使用 继承而来的 属性 方法 构造函数
s.name
s.sayHi()4.6 super关键字
子类通过 super 可以访问父类的实例字段、实例方法和构造函数。可以在适当的时候使用。
class 父类 {
func(){
}
}
class 子类 extends 父类 {
constructor() {
super() // 调用父类构造函数
}
方法(){
super.方法() // 调用父类方法
}
}代码：
class Person {
name: string
age: number
sayHi() {
console.log(`你好，我叫:${this.name}`)
}
constructor(name: string, age: number) {
this.name = name
this.age = age
}
}
class Student extends Person {
height: number
constructor(name: string, age: number, height: number) {
// name 和 age 的初始化通过 super 来调用父类的构造函数
super(name, age)
this.height = height
}
sayHi(): void {
// 通过 super 访问父类的 字段 方法
super.sayHi()
super.name
super.age
console.log('子类的 sayHi')
}
}
const s: Student = new Student('一只小风华~', 18, 175)4.7 instanceof
instanceof 运算符可以用来检测某个对象是否是某个类的实例。
// 返回判断结果 布尔值
实例对象 instanceof Class代码：
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)
console.log('isPerson', s instanceof Person)
console.log('isArray', [1, 2, 3,] instanceof Array)
const arr = [1, 2, 3]
// 等同于
const arr2 = new Array(1, 2, 3)4.8修饰符
类的方法和属性可以通过修饰符来 限制访问。
修饰符包括：readonly、private、protected和public。省略不写默认为 public。
4.8.1readonly（只读）
readonly 的意思是只读，可以用来修饰属性（字段），修饰之后外部只可以取值，无法修改。
class 类{
readonly 属性:类型
}4.8.2private（私有）
private修饰的成员不能在声明该成员的类之外访问,包括子类。
class 类{
private 属性:类型
private 方法(){}
}代码：
class Person {
// private 设置的时候不嫩省略
private name: string = ''
private age: number = 0
public sayHi() {
// 内部可以访问
console.log(`你好，我叫:${this.name}`)
}
}
class Student extends Person{
public sayHello() {
// 内部可以访问
console.log(`你好，我叫:${super.name}`) // 无法访问 报错
}
}
const p = new Person()
// p.name // 无法访问 报错
p.sayHi()4.8.3protected（受保护）
protected修饰符的作用与private修饰符非常相似，不同点是protected修饰的成员允许在派生类(子类) 中访问。
class 父类{
protect 属性:类型
protect 方法(){}
}
class 子类 extends 父类{
方法(){
// 可以访问父类 protect 修饰的 属性、方法
}
}代码：
// protect 受保护
class Person {
protected name: string = ''
private age:number=18
sayHi():void{
console.log(this.name)
console.log(this.age+'')
}
}
class Student extends Person{
sayHello(){
console.log(this.name) // 可以访问
console.log(this.age+'') // 无法访问 报错
}
}4.8.4.public（公共）
public修饰的类成员（字段、方法、构造函数）在程序的任何可访问该类的地方都是可见的。
class 类{
public 属性
public 方法(){}
}
默认的修饰符就是 public，外部可以访问。
代码：
class Person {
public name: string = ''
// 省略 等同于使用 public
age: number = 0
public sayHi(){
console.log(`你好，我叫:${this.name}`)
}
}
// public 公有
const p = new Person()
// 使用 public 修饰的字段和方法，通过对象直接可以访问
p.name
p.age
p.sayHi()总结：
| 修饰符名 | 作用 | 适用范围 | 访问限制 |
| readonly | 只读 | 属性 | 无限制 |
| private | 私有 | 属性、方法 | 类内部可以访问 |
| protect | 保护 | 属性、方法 | 类及子类可以访问 |
| public | 公共 | 属性、方法 | 无限制 |
5.剩余和展开
5.1剩余参数
通过剩余参数的语法，我们可以将函数或方法中一个不定数量的参数表示为一个数组。
// 剩余参数只能写在最后一位
function 函数名(参数1,参数2,...剩余参数数组){
// 逻辑代码
// 剩余参数之前的参数 挨个获取即可
// 剩余参数：以数组的形式获取
}代码：
function sum(numA:number,numB:number,...theArgs:number[]) {
let total = numA+numbB;
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()) // 105.2展开
出于程序稳定性，以及运行性能考虑，在 ArkTS 中 ...(展开运算符) 只能用在数组上。
代码：
const numArr1: number[] = [1, 2, 3, 4]
const numArr2: number[] = [5, 6, 7]
// 合并到一起
const totalArr: number[] = [...numArr1, ...numArr2]6.简单类型和复杂类型
ArkTS中的数据类型整体可以分为 两大类:
1. 基本数据类型（简单数据类型）
number 数字型、string 字符串型、boolean布尔型、undefined未定义、null空类型。
2. 引用数据类型（复杂数据类型）
Object、Function、Array。
这两类数据在内存中保存的方式略有不同，导致在日常开发中对这两类数据进行赋值操作时会有不同的 结果。
代码：
// 基本数据类型
let numA: number = 10
let numB: number = numA
numB++
console.log('numA:', numA) // ?
console.log('numB:', numB) // ?
// 引用数据类型
class Person {
name: string = ''
constructor(name: string) {
this.name = name
}
}
const p1: Person = new Person('jack')
const p2: Person = p1
// 修改 P2 是否会报错
p2.name = 'rose'
console.log('p1.name:', p1.name) // ?
console.log('p2.name:', p2.name) // ?6.1内存中堆栈空间
咱们可以把内存理解为有 2 类空间：
1. 栈：访问速度快，基本数据类型存放到栈里面。
2. 堆：存储容量大，引用数据类型存放到堆里面。
6.1.1基本数据类型存储
变量的数据直接存放在栈空间中，访问速度快。
6.1.2引用数据类型存储
1. 栈空间：存放 变量的内存地址（堆中的地址）。
2. 堆空间：存放 变量的 值。
6.2站在内存角度看变量赋值
6.2.1基本数据类型
num1 num2 都保存在堆内存中，虽然值相同，但是各自是独立的空间，后续操作 互不影响。
let num1: number = 10
let num2: number = num1
6.2.2引用数据类型
p1 和 p2 栈内存中有各自独立的空间，但是保存的是堆内存的地址，指向的是同一个数据：
修改 p2.name ，p1.name 也会受到影响，因为是同一份数据。
class Person {
name: string = ''
constructor(name: string) {
this.name = name
}
}
const p1: Person = new Person('jack')
const p2: Person = p1
p2.name = 'rose
讨论HarmonyOS开发技术，专注于API与组件、DevEco Studio、测试、元服务和应用上架分发等。
更多推荐
52
0- 0
已为社区贡献5条内容
所有评论(0)