ArkTS基础语法（下）

最近有些懒惰，总充斥这我的脑袋，总在挣扎的边缘哈哈

言归正传，继续学习

语句

条件语句

用于基于不同的条件来执行不同的动作，根据判断条件的执行结果（Ture或false）来决定执行的代码块。

let isValid: Boolean = false;
if(Math.random() > 0.5){
    isValid=true;
} else{
    isValid=false;
}

上面的例子中Math.random( )是生成0-1的随机数的内置math库的函数，这里根据其返回的结果，是否大于0.5，来给isValid进行赋值。

对于isValid的赋值，也可以使用条件表达式的方式，替换条件语句,如下：

let isValid = Math.random() > 0.5 ? ture : false;

循环语句

是一种重复执行一组语句的结构，能够提高效率和简化代码，例如下面要打印这个数组的内容：

let students:string[]=['Xiaoming','Jack','Mary'];

for循环语句

for(let i =1;i<students.length;i++){
    console.log(students[i]);
}

for of语句

for(let student of students){
    console.log(student);
}

while语句

let index=0;
while(index<students.length){
    console.log(students[index]);
    index++;
}

以上都可以进行输出数组中人物的姓名

函数的声明和使用

function函数

函数是一组一起执行多条语句的组合，形成可重用的代码块。

通过function关键字告诉编辑器声明函数的名称，返回类型和参数以及执行内容；

function()函数名（参数列表）：返回类型{

        函数体

}

一般用来定义特殊的任务或者操作，下面是通过函数来接受students的输入，只要在调用时传入不同的参数，就能执行打印不同的信息。

function printStudentsInfo(students:string[]):void{
    for(let student of students){
        console.log(student);
    }
}

printStudentsInfo(['Xiaoming','Xiaozhang','Xiaoliang'])
printStudentsInfo(['Xiaoming','Xiaohong'];)

箭头函数

箭头函数又叫做lambda表达式，可以用来简化函数的声明，通常用于一个需要简单函数的地方，箭头函数使用等于加大于连接参数。

（ 参数列表 ）： 返回类型 => { 函数体 }

箭头函数的返回类型可以省略，省略时，返回类型通过函数体来进行判断，在执行体只有一行的时候，可以省略花括号，并且，也可以将箭头函数赋值给一个变量，例如printInfo

const printInfo=(name:string):void=>{console.log(name)};

//一行可以省略花括号
const printInfo=(name:string):void=>console.log(name);
printInfo('Xiaoming');

大多时候，箭头函数用于作为回调函数使用,例如下面的代码块，在数组的forEach方法中，传入一个箭头函数，用于遍历时的操作。

let students:string[]=['Xiaoming','Xiaolan','Xiaohong'];
students.forEach((student:string)=>console.log(student));

闭包函数

闭包是函数式编程里面的一个有用的工具，通过闭包，创建一个函数并返回，可以保留对内部作用域的访问，如下面的例子：

function outerFunc():()=>string{
    let count=0;
    return():string=>{
    count++;
    return count.toString()
    }
}

let invoker = outerFunc()
console.log(invoker()) //输出1
console.log(invoker()) //输出2

在这个例子中，outerFunc的返回值是一个函数类型，在结果中返回了一个箭头函数，通过invoker接受了outerFunc( )的执行结果，invoker函数就保留了对count的访问，每次执行invoker函数的时候，都可以直接访问到count的值，如果在多个地方都可以用到，就可以使用type,对返回的函数类型取一个类型别名，方便后续的管理，如下：

type returnType = () =>string;             //使用该类型作为返回类型

function outerFunc():()=>returnType{       //声明一个函数类型
    let count=0;
    return():string=>{
    count++;
    return count.toString()
    }
}

let invoker = outerFunc()
console.log(invoker()) //输出1
console.log(invoker()) //输出2

类的声明和使用

类的声明，ArkTS支持基于类的面向对象的编程方式，定义类的关键字为class,后面紧跟类名。类的声明描述了所创建的对象共同的属性和方法。

可以将一个东西抽象化为一个类，之后用new关键字实例化出一个对象，并且通过点运算符的方式访问这个对象的属性，也可以通过字面量的方式进行创建

class person{
    name:string='Xiaoming';
    age:number=18;
    isMale:boolean=true;
}

const person=new Perple();                                   //new实例
console.log(person.name);

const person:Person = {name:'Xiaoming',age:18,isMale:true};   //字面量
console.log(person.name);          //输出Xiaoming

构造器，如果要实例化出不同的对象内容可以自定义constructor,在 constructor中，给对应的属性传入初值，那么在new的时候只需要传入接收到的参数就可以创造出不同的实例对象。

class person{
    name:string='Xiaoming';
    age:number=18;
    isMale:boolean=true;


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

const person =new Person('Xiaozhang',32,false); //通过传入参数实体化
console.log(person.name)

一个人，除了有自身的属性外，还可以执行一些行为，例如他可以进行自我介绍，对应到代码中就是类的方法这里定义一个printInfo方法来打印自身的信息，调用时，通过person.printInfo的方式实行对应实例的方法：

class person{
    name:string='Xiaoming';
    age:number=18;
    isMale:boolean=true;


    constructor(name:string,age:number,isMale:boolean){
    this.name=name;
    this.age=age;
    this.isMale=isMale;
    }
    
    printInfo(){
    if(this.isMale){
    console.log('${this.name}is a boy,and he is $[this.age}years old');
    }else{
    console.log('${this.name}is a girl,and he is $[this.age}years old');
    }
   } 
}

const person =new Person('Xiaozhang',28,true); //通过传入参数实体化
person.printInfo( )         //Xiaozhang is a boy,and he is 28 years old.

ArkTS支持面向对象的编程方式，那么就有面向对象的三大特征：封装，继承和多态

封装

封装是将数据和操作组合到一起，形成一个相对独立的实体，通过封装可以将数据隐藏起来，只对外部提供必要的接口来访问和操作数据，以保证数据的一致性和安全性。例如下面的：

class person{
   public name:string='Xiaoming';
   private _age:number=18;
    isMale:boolean=true;
    ...省略构造器和方法内容
    get age():number{
        return this._age;
    }

    set age():number{
        this._age=age;
    }
}

const person:Person=new Person('Xiaoming',18,ture);

console.log(person._age.toString())  //无法访问私有属性
console.log(person.age.toString())   //实际访问的是get方法

可以通过private修饰一个私有年龄，私有变量是无法通过对象直接访问的，访问只能通过getter或者自定义方法进行，那么这样就只暴露了接口，进行访问和操作数据，修改和访问时，则需要触发getter或者setter函数。

继承

继承是一种建立在现有类型上创建新类的机制，通过继承，子类可以继承并重用父类的属性和方法，从而减少重复代码，实现了代码的复用和层次化设计，继承使用extends关键字，例如一个员工也有人的特征，就可以用extends进行继承，在构造器中通过super来执行父类的构造方法那么Employee这个类也就具有了Person的基本属性，并且也具备了printInfo的方法，如下：

class Employee extends Person{
    department : string;

    constructor(name : string , age : number , isMale : boolean , department : string){
        super(name, age, isMale);   //通过super关键字访问父类
        this.department=department;
    }
}

const employee : Employee = new Employee('Xiaohong',28,ture,'xxCompany');
employee.printInfo();     //输出：Xiaohong is a boy,and he is 28 years old.子类继承父类的方法

通过实例化的Employee的对象，直接调用printInfo方法就可以打印出对应的信息。

多态

多态常常和继承一起，表示子类继承父类，并且重写父类方法，那么父类和子类的实例对象，在同一行为下就有不同的表现，例如Employee这个类，它重写了父类person的printInfo方法，其在方法中通过调用super实行了父类的printInfo方法，并额外执行了属于自己特有的行为，那么实例化后的Person和Employee在相同的行为下，就有了不同的表现，这就是多态的体现，如下：

class Employee extends Person{
    department : string;

    constructor(name : string , age : number , isMale : boolean , department : string){
        super(name, age, isMale);   //通过super关键字访问父类
        this.department=department;
    }
    
    public printInfo():string{                          //重写父类的方法
        super.printInfo();
        console.log('working in ${this.department}');
    }
}

const person:Person=new Person('Xiaohong',28,true);
person.printInfo(); //输出Xiaohong is a boy,he is 8 years old.

const employee : Employee = new Employee('Xiaohong',28,ture,'xxCompany');
employee.printInfo();     //输出：Xiaohong is a boy,and he is 28 years old,working in xxCompany.

接口的声明和使用

接口

接口是用来约束和规范类的方法，提高开发效率的工具，接口在程序设计中具有很重要的作用。

接口的声明

在 ArkTS中，我们可以通过interface关键字来声明接口，在接口中可以声明属性，也可以声明方法，但是不需要给属性具体得值和方法 给出对应的实现     

interface AreaSize{
    width:number;        //声明属性
    height:number;       //属性 2 
}

interface AreaSize{
    calculateAreaSize():number;   //方法的声明
    someMethod():void ;           //方法的声明
}

接口的使用

let area:AreaSize = {width: 100, height: 100};

对于只有属性的接口，可以通过字面量的方式创建对象实例，而如果接口中声明的方法，就无法通过字面量的方式来创建 。

接口的实现

在开发中，我们可以通过使用implements关键字，对接口进行实现，实现中必须遵循接口所约定的属性和方法，保持相同的名称，并且对接口中的声明的方法进行具体的实现

interface AreaSize{
    width:number;        //声明属性
    height:number;       //属性 2 

    calculateAreaSize():number;    //方法的声明
    someMethod():void;             //法方的声明           实现接口中约定的方法
}

//接口实现
class RectangleSize implements AreaSize{
    width:number=0;
    height:number=0;
    
    someMethod():void{                                    //实现接口中约定的方法
        console.log('someMethod called');
}

    calculateAreaSize():number{
        this.someMethod();
        return this.width * this.height;
    }
}

  

模块导入和导出

在实际开发中，我们可能在多个文件中进行开发，如果在多个模块中进行开发，那么就要了解模块的概念。

模块的定义

在应用开发中，我们会将代码拆分到多个文件，这样更加有利于开发的维护和管理，在ArkTS中，一个文件就可以是一个模块由于不同文件之间的作用域是隔离的，一个文件，如果想要引入其它文件中的函数类或者变量，就需要使用export和import关键字，来进行模块的导入或者导出。

例如下面的例子，刚刚定义的person类，我们需要在其他文件中引用这个类，首先就要在这个类的前面加一个修饰符export 

export class Person{                //导出所需要的类
    name:string='Xiaoming';
    age:number=18;
    isMale:boolean=true;

    ...省略构造器内容    
    printInfo(){
    if(this.isMale){
    console.log('${this.name}is a boy,and he is $[this.age}years old');
    }else{
    console.log('${this.name}is a girl,and he is $[this.age}years old');
    }
   } 
}

在另一个文件中通过impot的方式，从对应文件路径引入导入的Person类,这样就可以使用Person这个类了，在开发中合理使用模块的导入和导出，可以实现代码的复用和组合，能够提高编码效率。

import { Person } from './Person'
const person = new Person('Xiaozhang',20,true);
person.printInfo(); //输出Xiaozhang is a boy,he is 20 years old.