三、类
1.基本示例
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
| (() => {
// ts中类的定义
class Person{
// 定义属性
name:string
age:number
gender:string
// 定义构造函数：实例化对象的时候，可以直接对属性值进行初始化
constructor(name:string='he',age:number=18,gender:string='男' ){
// 更新对象中的属性数据
this.name = name
this.age = age
this.gender = gender
}
// 定义实例方法
sayHi(str:string){
console.log(`我叫${this.name},今年${this.age}了,我是${this.gender}的`,str);
}
// ts中使用类，实例化对象，进行实例化操作
}
const person = new Person('lisi',28,'nv')
person.sayHi('喜欢编程')
})()
|
2.继承：类与类之间的关系
继承后，类与类之间的叫法：A类继承了B类，那么A为子类【派生类】，B类为基类【超类，父类】
// 类：可以理解为模板，通过模板实例化对象
// 面向对象的编程思想
总结：使用关键字extends实现继承，子类可以调用父类中的构造函数，使用super调用,子类中可以重复父类中的方法sayHi
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
| (() => {
// 定义一个类，作为基类【超类，父类】
class Person{
// 定义属性
name:string
age:number
gender:string
// 定义构造函数：实例化对象的时候，可以直接对属性值进行初始化
constructor(name:string='he',age:number=18,gender:string='男' ){
// 更新对象中的属性数据
this.name = name
this.age = age
this.gender = gender
}
// 定义实例方法
sayHi(str:string){
console.log(`我叫${this.name},今年${this.age}了,我是${this.gender}的`,str);
}
// ts中使用类，实例化对象，进行实例化操作
}
// 定义一个类，作为子类【派生类】
class Student extends Person{
constructor(name:string='he',age:number=18,gender:string='男' ) {
// super:调用父类中的构造函数
super(name,age,gender)
}
// 调用父类的中方法
sayHi(){
super.sayHi('lisi')
}
}
// 实例化Person Student
const person = new Person('lisi',28,'nv')
const student = new Student('lisi',28,'男')
student.sayHi()
})()
|
3.多态：父类型引用了指向子类型的对象，不同类型的对象针对相同的方法，产生了不同的行为
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
| (() => {
// 定义一个父类
class Person{
// 定义属性
name:string
// 定义构造函数：实例化对象的时候，可以直接对属性值进行初始化
constructor(name:string='he'){
// 更新对象中的属性数据
this.name = name
}
// 定义实例方法
Run(num:number=0){
console.log(`我跑了${num}公里,`+this.name);
}
}
// 定义一个子类
class Student extends Person{
constructor(name:string='he') {
// super:调用父类中的构造函数
super(name)
}
// 实例方法，重写父类中的实例方法【Run】
Run(num:number=5){
console.log(`我跑了${num}公里,`+this.name);
}
}
// 定义一个子类
class Teacher extends Person{
constructor(name:string='he') {
// super:调用父类中的构造函数
super(name)
}
// 实例方法，重写父类中的实例方法【Run】
Run(num:number=10){
console.log(`我跑了${num}公里,`+this.name);
}
}
// 实例化Person Student Teacher
const person:Person = new Person('人')
person.Run()
const student:Student = new Student('学生')
student.Run()
const teacher:Teacher = new Teacher('老师')
teacher.Run()
// 父类和子类的关系：父子关系，父类类型创建子类的对象
// 父类型引用了指向子类型的对象
const student1:Person = new Student('学生1')
student1.Run()
const teacher1:Person = new Teacher('老师1')
teacher1.Run()
// 不同类型的对象针对相同的方法，产生了不同的行为
function showRun(person:Person) {
person.Run()
}
showRun(student1)
})()
|
4.修饰符（类中成员的修饰符）：主要修饰类中成员的【属性，构造函数，方法】可访问性
类中的成员都有默认的修饰符：public【公共的】、private【私人的，子类也无法访问】、protected【只能在子类中使用】readonly【将属性设置为只读的,类中的方法，也不能修改】
构造函数constructor中的参数name使用readonly(或者其他修饰符)后，类里面就有了该参数属性name
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
| (() => {
// 定义一个类
class Person{
// 定义一个属性
protected name:string
public age:number
// 定义构造函数：对属性值进行初始化
constructor(name:string='he',age:number=10){
// 更新对象中的属性数据
this.name = name
this.age = age
}
// 定义一个实例方法
protected Run(num:number){
console.log(`我跑了${num}公里,`+this.name+','+this.age);
}
}
class Student extends Person {
constructor(name:string="lisi",age:number=18) {
super(name,age)
}
Play(){
super.Run(3)
}
}
// 实例化对象
const student = new Student()
student.Play()
})()
|
1
2
3
4
5
6
7
8
9
| class Person {
readonly name: string = 'abc'
constructor(name: string) {
this.name = name
}
}
let john = new Person('John')
// john.name = 'peter' // error
|
5.存取器
TypeScript 支持通过 getters/setters 来截取对对象成员的访问
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
| class Person {
firstName: string = 'A'
lastName: string = 'B'
get fullName() {
return this.firstName + '-' + this.lastName
}
set fullName(value) {
const names = value.split('-')
this.firstName = names[0]
this.lastName = names[1]
}
}
const p = new Person()
console.log(p.fullName)
p.firstName = 'C'
p.lastName = 'D'
console.log(p.fullName)
p.fullName = 'E-F'
console.log(p.firstName, p.lastName)
|
6.静态属性:静态属性、静态方法，通过static来修饰属性和方法
静态成员是通过类名.属性或方法来调用的,实例对象不能调用静态属性和静态方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
| (() => {
class Person {
// static name:string 类中默认有name这个属性
name1: string = 'A'
static name2: string = 'B'
constructor(name1: string, name2: string) {
this.name1 = name1
// this是实例对象，name2为静态属性，实例对象不能调用静态属性
// this.name2= name2
}
static Run() {
console.log(123);
}
}
console.log(Person.name2)
Person.name2 = 'C'
console.log(Person.name2)
Person.Run()
// 实例对象不能调用静态属性和静态方法
// console.log(new Person('','').name2)
})()
|
7.抽象类：抽象类做为其它派生类的基类使用。 它们不能被实例化
不能实例化抽象类的对象 const animal = new Animal()，通过继承的方式实现,一般不用抽象属性
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
| (() => {
abstract class Animal {
// 抽象方法没有具体内容的实现
abstract name:string
abstract cry()
// abstract cry(){
// console.log(123);
// }
run() {
console.log('run()')
}
}
class Dog extends Animal {
name:string = '小白'
cry() {
console.log(this.name+' Dog cry()')
}
run(){
console.log(this.name+123);
}
}
// 不能实例化抽象类的对象 const animal = new Animal()，通过继承的方式实现
const dog = new Dog()
dog.cry()
dog.run()
})()
|