类

typescript 的类中添加了许多面向对象语言的特性

类的定义

1
2
3
4
5
6
7
class Dog {
    constructor(name: string) {
        this.name = name // 在ts中，类的属性必须初始化
    }
    name: string
    run() {}
}

类的继承

1
2
3
4
5
6
7
8
9
10
11
// 使用 extends 修饰符进行继承
class Husky extends Dog {
    constructor(name: string, color: string) {
        // 在构造器中 必须包含super调用
        super(name)
        // 给子类的属性初始化 必须在super后面
        this.color = color
    }
    color: string
}

类的公有，私有以及受保护成员

类中的成员默认是共有 public , 也可以使用私有 private, 私有成员只能在类的本身调用，不能被子类以及实例调用

protected受保护成员只能在 类或者子类中访问，不能在实例中访问

1
2
3
4
5
6
7
8
9
class Dog {
    // 当给构造函数添加private后，则说明这个类既不能被继承也不能被实例化
    private constructor(name: string) { 
        this.name = name
    }
    readonly age: number = 4 //只读成员，必须初始化
    private say() {} // 定义私有成员
    protected pro() {} // 定义受保护成员
}

类的静态成员

静态成员只能通过类名调用可以被继承， 不能通过子类调用

1
2
3
4
5
6
class Dog {
    constructor(name: string) { 
        this.name = name
    }
    static food: string = 'milk' // 定义受静态成员
}

抽象类

抽象类只能被继承，不能被实例化。

在抽象类中可以有具体的方法实现，这样方便子类调用

也可以没有具体的实现，这就构成一个抽象方法，在子类中必须实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
abstract class Animal {
    eat() {
        console.log('eat');
    }
    abstract sleep(): void;
} 


class Dog extends Animal{
    constructor(name: string) {
        super()
        this.name = name
    }
    name: string
    run() { }
    sleep() {
        console.log('dog sleep');
    }
}

多态

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
abstract class Animal {
    eat() {
        console.log('eat');
    }
    abstract sleep(): void;
}

class Dog extends Animal{
    constructor(name: string) {
        super()
        this.name = name
    }
    name: string
    run() { }
    sleep() {
        console.log('dog sleep');
    }
}

class Cat extends Animal{
    sleep() {
        console.log('cat sleep');
    }
}

let cat = new Cat()
let dog = new Dog('wangwangwang')
let animals: Animal[] = [cat, dog]
animals.forEach(i => {
    i.sleep() //每一个对象都会执行不同的sleep方法
})

类的链式调用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class WorkFlow {
    step1() {
        return this
    }
    step2() {
        return this
    }
}
class MyFLow extends WorkFlow {
    next() {
        return this
    }
}
// 调用子类的方法，返回子类的类型|再调用父类的方法，返回父类的类型|再调用子类的方法，返回子类的类型
new MyFLow().next().step1().next()

类实现接口

接口可以规范类的成员，类实现接口时，必须实现接口中的所有成员

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
interface Human {
    name: string
    eat() : void
}
class MySelf implements Human{
    constructor(name: string, age: number) {
        this.name = name
        this.age = age
    }
    age: number;
    name: string;
    eat() {
        console.log('i am eatting');
    }
}

接口继承接口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
interface Human {
    name: string
    eat() : void
}

interface Children extends Human{
    run(): void;
}

interface Boy extends Human, Children{ }
class Aboy implements Boy{
    constructor(name: string) {
        this.name = name
    }
    name: string
    eat() {
        console.log('aboy eatting');
    }
    run() {
        console.log('aboy running');
    }
}

接口继承类

1
2
3
4
5
6
7
class Animal {
    eat() {
        console.log('eatting');
    }
}
interface Dog extends Animal{}
// 此时，Dog接口中包含 Animal类中的成员

类和接口之前的关系

接口和接口之间可以继承，以实现接口的复用

类与类之间可以继承，以实现属性和方法的复用

接口可以通过类来实现，但是接口只能约束类的公有成员

接口也可以抽离出类的成员，抽离的时候会包括共有，私有和受保护成员

泛型

泛型可以保证 函数可以接受任意参数，且返回值类型与参数类型一致

泛型函数的定义

1
2
3
4
5
6
function log<T>(value: T): T {
    console.log(value);
    return value
}
log<string[]>(['a','b']) //声明泛型类型
log(['a','b']) // 使用类型推断

泛型接口的定义

1
2
3
4
5
6
7
8
9
10
function log<T>(value: T): T {
    console.log(value);
    return value
}
// 定义泛型接口，其默认为string类型
interface Log<T = string>{
    (value: T) : T
}
let myLog: Log = log
myLog('1')

泛型类的定义

1
2
3
4
5
6
7
8
class Log<T> {
    show(value: T) {
        console.log(value);
        return value
    }
}
let log1 = new Log<string>()
log1.show('hahah')