乐趣区

关于typescript:TypeScript类

jiezi

在 js 中，类（Class）定义了一件事物的形象特点，蕴含它的属性和办法。对象（Object）为类的实例，能够通过 new 关键字生成。
面向对象的三大个性：封装，继承，多态
封装：将对数据的操作细节暗藏起来，只裸露对外的接口。通过对外提供的接口来拜访该对象，同时也保障外界无奈任意更改对象外部的数据。
继承：子类继承父类，子类除了领有父类的所有个性外，还有一些更具体的个性
多态：由继承而产生了相干的不同的类，对同一个办法能够有不同的响应。
存取器 (getter&setter): 用以扭转属性的读取和赋值行为。
修饰符：一些用于限定成员或类型的性质的关键字。例如 public

  • TypeScript 中类的用法：
class Person{
    name: string
    age:number
    gender:string
    constructor(name:string='Liane',age:number=18,gender:string='female'){
    this.name = name
    this.age = age
    this.gender = gender
    }
    sayHi(str:string){console.log(`Hi ${str}, My name is ${this.name}, I'm ${this.age} years old`)
    }
}
let p0 = new Person()
p0.sayHi('Ann')

  • 继承：

    应用 extends 关键字，让子类继承自父类，应用 super 关键字调用父类的构造函数和实例办法，继承父类的属性和办法

    class Students extends Person{constructor(name: string, age:number,gender:string){super(name,age,gender)
    }
    sayHi(str){super.sayHi(str)
    }
}
let s0 = new Students('Jack',16,'man');
s0.sayHi('Liane')
  • 多态：

由继承而产生了相干的不同的类，对同一个办法能够有不同的响应。

class Animal{
    name: string
    constructor(name: string){this.name = name}
    eat(str:string){console.log(`${this.name} like to eat ${str}`)
    }
}
class Dog extends Animal{constructor(name:string='Tom'){super(name)
    }
    eat(str){super.eat(str)
    }
}
class Cat extends Animal{constructor(name:string='Jerry'){super(name)
    }
    eat(str:string){super.eat(str)
    }
}

let dog = new Dog()
let cat = new Cat()
dog.eat('bone') //Tom like to eat bone
cat.eat('fish') //Jerry like to eat fish

即 Dog 和 Cat 都继承自 Animal，但别离实现了本人的 eat 办法。

  • 类中的成员修饰符
    用来形容类中的属性、构造函数和办法的可拜访性

public: 默认修饰符，代表是公共的，在任何地位都能够被拜访。

private: 公有修饰符，内部和子类都无法访问这个成员。
当心愿有的成员无奈直接存取时，可应用 private 修饰符润饰该成员。
应用 private 润饰 constructor 时，该类不容许被继承或者实例化。

protected: 该修饰符润饰的成员，只能在其外部及子类中被拜访
应用 protected 润饰 constructor 时，该类只容许被继承，不容许实例化。

注：仅在 TS 编译时提醒谬误，在编译成 js 后，并没有限度 private 属性在内部的可拜访性或 protected 润饰构造函数的可实例化性。

  • readonly 修饰符
    润饰类中的属性成员，被润饰的属性不能在内部或类中的一般办法中被随便批改。能够在构造函数 constructor 中被批改。

    //readonly 润饰类中的属性
class Person{
    readonly name:string='jack' // 可设置默认值
    constructor(name:string){this.name = name // 能够在构造函数中批改 name}
    sayHi(){this.name = 'Hello' // 提醒谬误}
}
let p = new Person('Liane')// 容许实例化传入新的 name 值
p.name = 'Ann' // 提醒谬误
console.log(p.name) //Ann-- 即便提醒谬误，但若持续编译，编译后的 js 仍然不会限度批改 readonly 润饰的属性

    应用 readonly 润饰 constructor 的参数时，被润饰的参数称为参数属性

    class Person{constructor(readonly name:string){this.name = name}
}
let p1 = new Person('Liane')
consoel.log(p1.name) //Liane
p1.name = 'Jack' // 提醒谬误
// 咱们发现，在 cosntructor 的参数前加上修饰符 readonly，则该类中会主动增加一个被 readonly 润饰的属性成员，类比不难发现，结构函数参数应用 public,private,protected 与应用 readonly 统一。

    构造函数中的参数能够应用 readonly 进行润饰，一旦润饰，则该类中就有了这个只读参数的成员属性，内部能够拜访，但不能批改。
    同理，构造函数中的参数能够应用 public,private 和 protected 进行润饰，无论是哪个修饰符，该类中都会主动增加一个被该修饰符润饰的属性成员。

  • 存取器
    让咱们能够无效的管制对对象中的成员的拜访和批改。通过 getter 和 setter 来进行操作。

    class Person{
    firstName: string
    lastName: string
    constructor(firstName:string,lastName:string){
        this.firstName = firstName
        this.lastName = lastName
    }
    get fullName(){return this.firstName + '_' +this.lastName}
    set fullName(value){const names = value.split('_')
        this.firstName = names[0]
        this.lastName = names[1]
    }
}
let p = new Person('诸葛','孔明')
console.log(p.fullName) // 诸葛_孔明
p.fullName = '司马_相如'
console.log(p.firstName) // 司马

  • 动态成员
    在类中通过 static 润饰的属性或办法，称为动态属性和静态方法，也称为动态成员。动态成员不会被实例继承，但能够被子类继承。
    动态成员应用时通过类名.xxx 的语法来调用

    class A{
    static n:number = 0
    static fun(){
        A.n++
        console.log(A.n)
    }
}
let a0 = new A()
console.log(a0.n) // 提醒谬误，持续编译后会打印 undefined
console.log(a0.fun()) // 提醒谬误，编译后会报错
console.log(A.n) //0
A.n = 100
console.log(A.n) //100
A.fun() //101

  • 抽象类
    抽象类：蕴含形象办法 (形象办法个别没有任何具体内容的实现)，也能够蕴含实例办法，抽象类是不能被实例化的，为了让子类进行实例化及实现外部的形象办法。
    应用 abstract 定义一个抽象类和其中的形象办法。

    // 定义一个抽象类
abstract class Animal1{
    name:string
    age: number
    constructor(name:string,age:number){
        this.name = name
        this.age = age
    }
    abstract eat(str) // 定义一个形象办法，形象办法不容许具备任何内容
    sayHi(){ // 抽象类能够蕴含实例办法
        console.log(`Hi,I am ${this.name}`)
    }
}
// 定义一个子类继承自抽象类
class Dog1 extends Animal1{eat(str){ // 必须定义形象办法的实例办法，否则报错
       console.log(`${this.name} like to eat ${str}`) 
    }
}
let dog0 = new Animal1('Jack') // 报错
let dog1 = new Dog1('Jack',2)
dog1.eat('bone') //Jack like to eat bone
dog1.sayHi() //Hi,I am Jack
退出移动版