初识arkts2
类
类声明引入一个新类型，并定义字段，方法和构造函数
属性 必须要给初始值
constructor():构造函数
定义类后，可以使用关键字new创建实例
export class PersonStudent{
firstName:string=''//名
lastName:string=''//姓
//constructor():构造函数：给属性初始值，初始化属性
// constructor() {
// console.log('无参函数')
// }
constructor(firstName:string='',lastName:string='') {
this.firstName=firstName
this.lastName=lastName
}
//函数，不能写function
fullName(){
//this调用自己的属性
return this.lastName+this.firstName
}
}
字段
字段时直接在类中声明的某种类型的变量
类可以具有实例字段或者静态字段
实例字段
要访问实例函数，需要使用类的实例
//实例字段
let p:PersonStudent=new PersonStudent('z','s')
//实例字段，通过new对象之后进行访问的字段
p.firstName='啧啧啧';
静态函数
使用关键字static将字段声明为静态。
要访问静态字段，需要使用类名
构造函数不允许使用静态字段
class person3{
//静态字段:static
static firstName:string=''
lastName:string=''
// static constructor() {
// }
}
静态函数
不支持this，无法直接访问非静态字段/函数
静态字段使用类名进行访问
class person3{
a2(){
}
a3(){
this.a2()
}
//静态函数
static a(num1:number,num2:number){
person3.firstName='张三'
//不支持this，无法直接访问非静态字段/函数
// this.lastName='aa'
//无法直接访问函数
// a2();
return num1+num2
}
}
//不用new对象进行访问
person3.firstName='ss'
//静态访问a()
person3.a(1,2)
继承
一个类可以继承另一个类·，继承类继承父类的字段和方法，但不继承构造函数。继承可以新增定义字段和方法，也可以覆盖其父类的方法
继承extends
子类 只支持单继承（只能继承一个父类）
必须调用父类的有参的构造函数，构造函数必须调用，但不能继承
关键字super可用于访问父类的实例字段、实例方法和构造函数。在实现子类功能时，可以通过该关键字从父类中获取所需接口
//父类
class Pet{
name:string=''
sex:string=''
static age:number=0
constructor(name:string,sex:string) {
this.name=name
this.sex=sex
//不能使用静态 static age:number=0
}
//函数
show(){
return `昵称:${this.name},性别:${this.sex}`
}
}
//子类
class Dog extends Pet{
constructor(name:string,sex:string) {
//关键词：super
super(name,sex)
}
//子类自己的属性
type:string=''
//重写
show(){
//方法不一样，结果一样
return super.show()+'品种:'+this.type
// return `昵称:${this.name},性别:${this.sex},品种:${this.type}`
}
a(){
this.show()//子类
super.show()//父类
}
}
let pe=new Pet('张三','男')
//当子类的函数和父类的函数重名，会调用子类的函数
pe.show()
重写
子类重写父类的函数
要求：1.方法名相同
2.参数类型相同
3.返回值类型相同，或者其子类
show(){
return super.show()+'品种:'+this.type
return `昵称:${this.name},性别:${this.sex},品种:${this.type}`
}
重载
同一个类中，方法名相同，参数列表不同，返回值类型相同
class Over{
//重载
aa(x:number):void
aa(x:string,k:number):void
aa(x:number|string,k?:number):void{
}
}
class Oo extends Over{
aa(x:number):void
aa(x:string):void
aa(x:number|string):void{
}
}
可见性修饰符
public修饰的类成员在程序的任何可访问该类的地方都是可见的
private修饰的成员不能再声明该声明的类之外访问
protected修饰符的作用与private修饰符非常相似，不同点是protected修饰的成员允许在子类中访问
class Aa{
//public:共有的
public a1:string=''
// protected 受保护的:本类和子类中使用
protected a2:string=''
//private私有的
private a3:string=''
}
class Bb extends Aa{
show(){
this.a2='asd'
}
}
let aa=new Aa()
let bb=new Bb()
aa.a1;
getter和setter可以用提供对对象属性的受控访问
//可见性修饰
class pri{
private _a1: string
public set a1(value: string) {
this._a1 = value
}
public get a1(): string {
return this._a1
}
private _a2: string
public set a2(value: string) {
this._a2 = value
}
public get a2(): string {
return this._a2
}
constructor(a1: string, a2: string) {
this._a1 = a1
this._a2 = a2
}
}
let p1=new pri('1','2');
p1.a1='a'
Record类型的对象字面量
泛型Record<k,v> 键值对
let map:Record<string,string>={
'name':'张三',
'sex':'男',
'color':'黄'
}
let names=map['name'];
class Stu{
name:string=''
age:number=0
}
//Record 存数据，键值对数据
let map2:Record<string,Stu>={
'张三':{name:'张三',age:18},
'李四':{name:'李四',age:18},
'李五':{name:'李五',age:18},
'李六':{name:'李六',age:18},
'李其':{name:'李其',age:18},
}
let s:Stu=map2['张三'];
接口
接口声明引入新类型，接口是定义代码协定的常见方式
接口通常包含属性和方法的声明
//接口
interface Stus{
//接口中的方法，没有方法体（方法的实现）
eat():void
study():number
}
//（实现类）实现接口，必须重写接口中的方法
class Stu1 implements Stus{
eat(): void {
console.log('学生在吃')
}
study(): number {
console.log('学生在学习')
return 100
}
}
接口属性
接口的属性会在实现类中默认隐式生成getter/setter方法
interface Stu2{
name:string
sex:string
eat():void
study():number
}
class Stu3 implements Stu2{
name: string=''
sex: string=''
eat(): void {
throw new Error('Method not implemented.')
}
study(): number {
throw new Error('Method not implemented.')
}
}
let stu3=new Stu3()
stu3.name='123'
接口继承
接口可以继承其它接口
继承接口包含被继承接口的所有属性和方法，还可以添加总结的属性和方法
interface Inte1{
a():void
}
interface Inte2 extends Inte1{
b():void
}
class Imp1 implements Inte2{
b(): void {
throw new Error('Method not implemented.')
}
a(): void {
throw new Error('Method not implemented.')
}
}
实现多个接口
interface A1{
a():void
}
interface B1{
b():void
}
class C1 implements A1,B1{
b(): void {
throw new Error('Method not implemented.')
}
a(): void {
throw new Error('Method not implemented.')
}
}
多态的实现方法，同一个方法在不同条件得到不同的结果
继承中的多态
接口实现的多态和继承实现的多态没有区别
class Pet{//父类
name:string=''
play():void{
console.log('玩耍')
}
}
class Dog extends Pet{//子类
play():void{
console.log('狗踢皮球')
}
}
class Cat extends Pet{//子类
play():void{
console.log('猫玩狗')
}
}
// 1.以父类作为形参
function play(pet:Pet){
pet.play()
}
play(new Cat())
play(new Dog())
// 2.以父类作为返回值
function ly():Pet{
let num=Math.random()*10
if(num>5){
return new Dog()
}else {
return new Cat()
}
}
泛型
泛型类型和函数允许创建的代码在各种类型上运行，而不仅支持单一类型
泛型的通配符
泛型 T:type类,
K:key ,
V:value,
E:element集合，
N:number
？:不确定的类型
class Fx<E>{
a(e:E):void{
console.log(`${e}`)
}
}
let fx=new Fx<number[]>();
fx.a([1,2])
泛型函数
//返回数字数组的最后一个元素
function lastGet(x:number[]):number{
return x[x.length-1]
}
//调用
let aa=lastGet([1,2,3,4])
//返回任意类型数组的最后一个元素
function getLast<T>(x:T[]):T{
return x[x.length-1]
}
//调用
let a2=getLast<string>(['1','2','as'])
原文地址：https://blog.csdn.net/syj_111/article/details/143893881
免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！