鸿蒙ArkTS中的面向对象编程
ArkTS是TypeScriptS的超集，而TS又是JavaScript的超集，意味着有JavaScript编程基础、结合一些TypeScript的使用经验就可以很快上手ArkTS。
作为一门面向对象语言的学习，了解和掌握这门语言的面向对象（封装、继承、多态）、面向接口、面向抽象的知识很有必要。
一、面向对象
1、封装
是面向对象编程中的一个核心概念，它允许将对象的数据（属性）和行为（方法）捆绑在一起，并对外隐藏内部的实现细节。
class Person {
// 属性
nationality: string = '中国'; // 国籍
name?: string; // 姓名
age?: number; // 年龄
gender?:string
constructor(name: string, age?: number,gender?:string) {
this.name = name;
this.age = age;
this.gender=gender
}
// 方法
SelfIntroduction(){
if (this.age !== undefined && this.age !== null && this.age >0) {
console.log(`My name is ${this.name}, and I am ${this.age} years old this year.`);
} else {
console.log(`My name is ${this.name}`);
}
}
Study(){
console.log(`${this.name} is studying mathematics diligently.`);
}
}
let Student:Person=new Person('小明',undefined,'male')
let Teacher:Person=new Person('宋老师',35,'female')
let Worker:Person=new Person('小王')
Student.SelfIntroduction()
Teacher.SelfIntroduction()
Worker.SelfIntroduction()
Teacher.Study()上面声明变量时如果不赋值，可以在变量名后面加？，包括对象的方法调用时传参也可以加？，但是如果后面紧跟着参数，该位置如果不传参数必须是undefined。
这样传递参数时可以是变化的。
这里也可以使用展开运算符来解决多参数传递的问题，例如：
function sum(num1:number,num2:number,...others:number[]):number{
let total=num1+num2
others.forEach(element => {
total+=element
});
return total
}
console.log(sum(1,2).toString())
console.log(sum(1,2,3,4,5).toString())当然，如果是多个参数传递，灵活一些应该将参数封装为一个（基于接口的）对象。
声明接口：
interface Para{
name: string
age: number
gender:string
}传递参数：
constructor(ParaObj:Para) {
this.name = ParaObj.name
this.age = ParaObj.age
this.gender=ParaObj.gender
}实例化：
let Student:Person=new Person({
name:'小明',
age:18,
gender:'男'
})正规一些的写法：
interface Para{
name: string
age: number
gender:string
}
class Person {
// 属性
protected nationality: string = '中国' // 国籍
public name: string // 姓名
private _age: number // 年龄
private _gender:string
constructor(ParaObj:Para) {
this.name = ParaObj.name
this._age = ParaObj.age
this._gender=ParaObj.gender
}
get age():number{
return this._age
}
set age(value:number){
this._age=value
}
// 方法
public SelfIntroduction(){
if (this.age !== undefined && this.age !== null && this.age >0) {
console.log(`My name is ${this.name}, and I am ${this.age} years old this year.`);
} else {
console.log(`My name is ${this.name}`);
}
}
}
let Student:Person=new Person({
name:'小明',
age:18,
gender:'男'
})
Student.age=25
Student.SelfIntroduction()
console.log(Student.age.toString())正规一些的写法比较繁琐，但是能有效保护数据，上面的例子中_gender属性没有提供对应的get和set方法，除了初始化能赋值外，外面不能访问。
2、继承
继承允许一个类（子类）继承另一个类（父类）的属性和方法，这有助于代码复用和扩展。
interface Para{
name: string
age: number
}
class Person {
// 属性
protected nationality: string = '中国' // 国籍
public name: string // 姓名
private _age: number // 年龄
constructor(ParaObj:Para) {
this.name = ParaObj.name
this._age = ParaObj.age
}
get age():number{
return this._age
}
set age(value:number){
this._age=value
}
// 方法
public SelfIntroduction(){
if (this.age !== undefined && this.age !== null && this.age >0) {
console.log(`My name is ${this.name}, and I am ${this.age} years old this year.`);
} else {
console.log(`My name is ${this.name}`);
}
}
}
class Student extends Person{
//重写构造函数
constructor(ParaObj:Para) {
super(ParaObj); // 调用父类的构造函数
//执行其他操作
}
Study(){
console.log(`${this.name} is studying。`);
}
}
let Student1:Student=new Student({
name:'小明',
age:18,
})
Student1.age=25
Student1.SelfIntroduction()
console.log(Student1.age.toString()) 3、多态
多态是指子类可以重写继承自父类的方法，使得同一个方法在不同的子类中可以有不同的实现。
class Person {
// 属性
public name: string // 姓名
constructor(name:string) {
this.name = name
}
// 方法
Action(){
console.log('')
}
}
class Student extends Person{
Action(){
console.log(`${this.name} is studying。`);
}
}
class Teacher extends Person{
Action(){
console.log(`${this.name} is giving a lecture。`);
}
}
let Student1:Student=new Student('小明')
Student1.Action()
let Teacher1:Teacher=new Teacher('王老师')
Teacher1.Action()二、面向接口
⑴当需要定义一个类应该具备的方法签名，但不提供方法的具体实现时，使用接口。
⑵当需要实现代码的松耦合，或者需要一个类遵循某些约定和规范时，使用接口。
interface Shape {
draw(): void;
}
class Circle implements Shape {
radius: number;
constructor(radius: number) {
this.radius = radius;
}
draw(): void {
console.log(`画一个半径为 ${this.radius} 的圆.`);
}
}
class Rectangle implements Shape {
width: number;
height: number;
constructor(width: number, height: number) {
this.width = width;
this.height = height;
}
draw(): void {
console.log(`画一个宽为 ${this.width} 高为 height ${this.height}的矩形.`);
}
}继承多接口的例子：
class Person {
name: string = '';
age: number = 0;
constructor(name: string, age: number) {
this.name = name;
this.age = age;
}
Info(): string {
return `${this.name}, ${this.age}`;
}
}
interface Introduce {
SayHello(): string;
}
interface Work{
Study():void;
}
class Student extends Person implements Introduce,Work {
grade: number = 0;
constructor(name: string, age: number, grade: number) {
super(name, age);
this.grade = grade;
}
SayHello(): string {
return `我是${this.grade}年级的学生，名叫${this.name}`;
}
Study(){
console.log(`${this.name} 正在学习`)
}
}
let Student1:Student = new Student('小明', 18, 9);
console.log(Student1.Info())
console.log(Student1.SayHello());
Student1.Study()
三、面向抽象
⑴当需要在多个子类之间共享代码时，使用抽象类。
⑵当需要强制子类实现某些方法，或者在共性较多的对象间寻求功能上的差异时，使用抽象类。
abstract class Animal {
name: string;
constructor(name: string) {
this.name = name;
}
//吃
abstract eat(food: string): void;
//睡，有默认实现
sleep(hours: number): void {
console.log(`${this.name} is sleeping for ${hours} hours.`);
}
}
//Dog
class Dog extends Animal {
constructor(name: string) {
super(name);
}
eat(food: string): void {
console.log(`${this.name} is eating ${food}.`);
}
}
//Cat
class Cat extends Animal {
constructor(name: string) {
super(name);
}
eat(food: string): void {
console.log(`${this.name} is eating ${food}.`);
}
}
let dog1:Dog=new Dog('虎仔')
let cat1:Cat=new Cat('小花')
dog1.eat('骨头')
cat1.eat('猫食')
dog1.sleep(2)