原文:TypeScript基本知识点整理
一、访问修饰符
- public - 公共修饰符,表示属性或者方法是公有的,在 类内部、子类内部、类的实例 都能被访问。
class People { public name : string constructor(name:string) { //构造函数必须写 this.name = name } public say() :void { console.log('你好') } }
- private - 私有修饰符,表示在当前类中可以访问,子类,外部类都不可以访问。
class People { private name : string constructor(name:string) { //构造函数必须写 this.name = name } private say() :void { console.log('你好') } }
- protected - 保护类型,表示在当前类和子类中可以访问,外部类不可以访问。
class People { protected name : string constructor(name:string) { //构造函数必须写 this.name = name } protected say() :void { console.log('你好') } }
- readonly - 只读修饰符,表示某个属性是制度的,不能被修改。
注意:TypeScript 只做编译时检查,当你试图在类外部访问被 private 或者 protected 修饰的属性或方法时,TS 会报错,但是它并不能阻止你访问这些属性或方法。
二、声明类
class People {
name : string //默认为public
age : number
constructor(name:string, age:number) { //构造函数必须写
this.name = name
this.age = age
}
say() :void {
console.log('你好')
}
}
const HH : People = new People('含含', 21)
console.log(HH.name)
console.log(HH.age)
HH.say()
三、类的继承
class People {
name : string //默认为public
age : number
constructor(name:string, age:number) { //构造函数必须写
this.name = name
this.age = age
}
say() :void {
console.log('你好')
}
}
class Student extends People {
cm : number
constructor (name:string, age:number, cm:number) {
super(name, age) //super 继承父类的构造函数,并向构造函数传参,super必须写在第一行
this.cm = cm
}
work() : void {
console.log('学习')
}
}
const stu1 : Student = new Student('liu', 22, 175)
console.log(stu1.name)
console.log(stu1.age)
console.log(stu1.cm)
stu1.say()
stu1.work()
四、静态方法和静态属性
- 静态方法和静态属性必须使用类名调用;
- 静态属性和静态方法在实例化之前就已经存在;
class People {
static name1 : string = '静态属性';
static say () :void {
console.log('静态方法')
}
}
console.log(People.name1)
People.say()
注意:静态方法调用不了实例化方法和实例化属性,因为静态域加载是在解析阶段,而实例化是在初始化阶段,(java原理),所以静态方法里面不能调用本类的方法和属性,可以调用静态属性和静态方法。
五、多态
父类定义一个方法可以不去实现,让继承它的子类去实现,每个子类的该方法有不同的表现;
class Animal {
name : string
constructor (name:string) {
this.name = name
}
eat () : void {
//让它的子类去实现不同的eat方法
console.log('animal eat')
}
}
class Laohu extends Animal {
constructor (name:string) {
super(name)
}
eat () : void {
console.log(`${this.name}吃肉!`)
}
}
class Laoshu extends Animal {
constructor (name:string) {
super(name)
}
eat () : void {
console.log(`${this.name}吃粮食!`)
}
}
const laohu : Laohu = new Laohu('老虎')
laohu.eat()
const laoshu : Laoshu = new Laoshu('老鼠')
laoshu.eat()
六、接口和类
类可以实现(implement)接口。通过接口,你可以强制地指明类遵守某个契约。你可以在接口中声明一个方法,然后要求类去具体实现它。
接口不可以被实例化,实现接口必须重写接口中的抽象方法。
interface Play {
plays (difang:string) : void;
}
class Playy implements Play {
plays(difang: string): void {
console.log(`我们要去${difang}玩!!!`)
}
}
const pl : Playy = new Playy();
pl.plays('北京')
七、抽象类:
抽象类是提供其他类继承的基类,不能直接被实例化,子类继承可以被实例化;
1.用abstract关键字定义抽象类和抽象方法,抽象类中的抽象方法不包含具体实现并且必须在派生类(抽象类的子类)中实现;
2.abstract修饰的方法(抽象方法)只能放在抽象类里面;
3.抽象类和抽象方法用来定义标准(比如定义标准为:抽象类Animal有抽象方法eat,要求它的子类必须包含eat方法)
abstract class People {
name : string
constructor (name:string) {
this.name = name
}
abstract eat (food:string) :void;//抽象方法不包括具体实现,并且必须再派生类中实现
}
class Stud1 extends People {
//抽象类的子类必须实现抽象类中的抽象方法
constructor (name:string) {
super(name)
}
eat(food: string): void {
console.log(`我爱吃${food}`)
}
}
const stu11 : Stud1 = new Stud1('liu')
stu11.eat('面条')
抽象类与接口的区别:
1.类可以实现(implement)多个接口,但只能扩展(extends)自一个抽象类。
2.抽象类中可以包含具体实现,接口不能。
3.抽象类在运行时是可见的,可以通过 instanceof判断。接口则只在编译时起作用。
4.接口只能描述类的公共(public)部分,不会检查私有成员,而抽象类没有这样的限制。