乐趣区

关于typescript:TypeScript类

在 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
退出移动版