HarmonyOS Next快速入门：数据类型和类

##HarmonyOS Next快速入门##HarmonyOS应用开发##教育##

****************************

数据类型

//布尔类型
let isDone: boolean = false;

//数字类型
let decLiteral: number = 2023; //十进制
let binaryLiteral: number = 0b11111100111; //二进制
let octalLiteral: number = 0o3747; //八进制
let hexLiteral: number = 0x7e7; //十六进制
console.log("decLiteral",decLiteral);
console.log("binaryLiteral",binaryLiteral);
console.log("octalLiteral",octalLiteral);
console.log("hexLiteral",hexLiteral);

//字符串，使用双引号（ "）或单引号（'）表示字符串
let username: string = "Jacky";

//数组
let list1: number[] = [1, 2, 3]; //方式1
let list2: Array<number> = [1, 2, 3]; //方式2

//元组，元组类型允许表示一个已知元素数量和类型的数组，各元素的类型不必相同。
let x: [string, number];
x = ['hello', 10]; // OK
x = [10, 'hello']; // Error

//枚举
enum Color {Red, Green, Blue};
let c: Color = Color.Green;

//联合类型
let myFavoriteNumber: string | number;
myFavoriteNumber = 'seven';
myFavoriteNumber = 7;

//Unknown，未知变量
let notSure: unknown = 4;
notSure = 'may be string';
console.log("notSure",notSure);
notSure = false;
console.log("notSure",notSure);

//Null和Undefined
let u: undefined = undefined;
let n: null = null;

类

//类的定义
class Person {
  private name: string; //属性
  private age: number; //属性

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

  //方法
  public getPersonInfo(): string {
    return `My name is ${this.name} and age is ${this.age}`;
  }
}

//类的调用
let person1 = new Person('Jacky', 18);
let info1 = person1.getPersonInfo();
console.log(info1);

//类的继承
class Employee extends Person {
  private department: string;

  constructor(name: string, age: number, department: string) {
    super(name, age); //调用父级构造函数
    this.department = department;
  }

  public getEmployeeInfo(): string {
    return this.getPersonInfo() + ` and work in ${this.department}`;
  }
}

let person2 = new Employee('Tom', 28, 'HuaWei');
let info2= person2.getPersonInfo();
let eInfo2 = person2.getEmployeeInfo();
console.log(info2);
console.log(eInfo2);

随着应用越来越大，通常要将代码拆分成多个文件，即所谓的模块（module）。模块可以相互加载，并可以使用特殊的指令 export 和 import 来交换功能，来调用另一个模块的函数。

导出

export class Person {
  private name: string; //属性
  private age: number; //属性

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

  //方法
  public getPersonInfo(): string {
    return `My name is ${this.name} and age is ${this.age}`;
  }
}

导入

import { Person } from './Person';

//类的调用
let person1 = new Person('Jacky', 18);
let info1 = person1.getPersonInfo();
console.log(info1);

接口

//接口
interface People {
    say(msg:string):void
}

class Chinese implements People{
    say(msg:string){
        console.log("中国人说",msg);
    }
}

class British implements People{
    say(msg:string){
        console.log("The British say",msg);
    }
}

let man:People=new Chinese();
man.say("中国欢迎您");
man=new British();
man.say("Welcome to the UK")