1. 类的定义
class Pointer {
x: number
y: number // 声明的变量会被增加到实例上
// 此函数中依然可以使用 剩余运算符 可选参数 默认参数
// 传入的实例直接就放在实例上，无需再次声明
constructor(x: number, y?: number, ...args: number[]){ // 在constructor中的操作都是初始化操作
this.x = x;
this.y = y as number;
}
}
let p = new Pointer(100,200)
console.log(p.x, p.y)
2. 类中的修饰符
- public 公开的，都可以访问到
class Animal {
public name!: string // 不写默认也是 public
public age!: number
constructor(name: string, age: number){
this.name = name
this.age = age
}
}
class Dog extends Animal {
constructor(name: string, age: number){
super(name, age)
console.log(this.name, this.age) // 子类访问
}
}
let p = new Dog('Jack', 6)
console.log(p.name, p.age) // 外部访问
- protected 受保护的，只能自己和子类访问
class Animal {
constructor(protected name: string, protected age: number){ // 简化写法
this.name = name
this.age = age
console.log(this.name, this.age) // 自己可以访问
}
}
class Dog extends Animal {
constructor(name: string, age: number){
super(name, age)
console.log(this.name, this.age) // 子类可以访问
}
}
let p = new Dog('Jack', 6)
// console.log(p.name, p.age) // 外部无法访问
- private 私有的，只有自己可以访问
class Animal {
constructor(private name: string, private age: number){
this.name = name
this.age = age
console.log(this.name, this.age) // 自己可以访问
}
}
class Dog extends Animal {
constructor(name: string, age: number){
super(name, age)
// console.log(this.name, this.age) // 子类无法访问
}
}
let p = new Dog('Jack', 6)
// console.log(p.name, p.age) // 外部无法访问
- readonly 只能读取
class Animal {
constructor(readonly name: string,public age: number){
this.name = name
this.age = age
}
changeName(name: string){
this.name = name; // 无法修改，仅读属性只能在constructor中被赋值
}
}
class Dog extends Animal {
constructor(name: string, age: number){
super(name, age)
}
}
let p = new Dog('Jack', 6)
p.changeName('Tom')
3. 静态属性和方法
class Animal {
static type = '哺乳动物'; // 静态属性
static getName() { // 静态方法
return '动物类';
}
private _name: string = 'Tom';
get name() { // 属性访问器
return this._name;
}
set name(name: string) {
this._name = name;
}
}
let a = new Animal();
console.log(a.name);
4. super 属性
class Animal {
say(message:string){
console.log(message);
}
static getType(){
return '动物'
}
}
class Cat extends Animal {
say(){ // 原型方法中的super指代的是父类的原型
super.say('猫猫叫');
}
static getType(){ // 静态方法中的super指代的是父类
return super.getType()
}
}
let cat = new Cat();
console.log(Cat.getType())
5. 类的装饰器
- 装饰类
装饰器作用就是扩展类，扩展类中的属性和方法 , 但不能修饰函数，函数会有变量提升的问题
function addSay1(val: string) { // 洋葱模型
console.log(val)
return function (target: any) {
console.log(1)
}
}
function addSay2(val: string) {
console.log(val)
return function (target: any) {
console.log(2)
}
}
function addSay3(val: string) {
console.log(val)
return function (target: any) {
console.log(3)
}
}
@addSay1('a1')
@addSay2('a2')
@addSay3('a3') // = addSay(Person);
class Person{
} // a1 a2 a3 3 2 1
// 装饰类可以给类扩展功能，需要在tsconfig.json开启 experimentalDecorators:true
- 装饰类中的属性
function toUpperCase(target: any, key: string){ // target 类的原型，key就是修饰的属性
let val: string = ''
Object.defineProperty(target, key, { // 原型定义属性
get(){
return val.toUpperCase()
},
set(newVal: string){
val = newVal
}
})
}
function double(num: number){
return function(target: any, key: string){
let v = target[key]
Object.defineProperty(target, key, {
get(){
return num * v
}
})
}
}
class Person{
@toUpperCase
public name: string = 'Tom'; // 修饰的是实例，装饰器指的就是原型
@double(2)
static age: number = 18; // 修饰的是静态属性，装饰器指的就是类
}
let p = new Person();
console.log(p.name) // TOM
console.log(Person.age) // 36 静态属性需要通过类来调用
- 装饰类中的方法
function Enum(bool: boolean){ // 修改方法不能枚举
return function (target: any, key: string, descriptor: PropertyDescriptor){ // target 指原型
descriptor.enumerable = bool
}
}
class Person{
@Enum(false)
drink(){}
}
let p = new Person();
console.log(p)
- 装饰参数
function params(target: any, key: string, index: number){ // target 原型 key 指方法drink index 索引0
console.log(key, index)
}
class Person{
drink(@params content: any){} // 修饰参数
}
