攀爬TS之路(七) 类与接口

这里不会赘述JS中的类的用法，而是单刀直入，直接来TS中的类的用法。

访问修饰符

先提一嘴，JS中的类有私有属性，在属性名之前使用#表示。私有属性只能在类的内部使用。

class Person {
    #name = 'clz'

    get val() {
        return this.#name
    }
}

const person = new Person()
console.log(person.val)

有学过其它语言的可能就会用的有点不太习惯，因为很多语言(指本人课程教的，C++、Java)使用的访问修饰符是public、private、protected。而TS可以使用这三种访问修饰符。

public：修饰的属性和方法是公有的，可以在任何地方被访问。默认都是public
private：私有的，只能在声明该属性的类中访问，即也不能被子类访问
protected：受保护的，和private类似，不过，能被子类访问

public

修饰的属性和方法是公有的，可以在任何地方被访问。

class Person {
    public name;
    public constructor(name) {
        this.name = name
    }
}

class Student extends Person {
    public grade;

public constructor(name, grade) {
        super(name)

console.log(this.name)
        this.grade = grade
    }
}


const student = new Student('czh', 3)      // czh

const person = new Person('clz')
console.log(person.name)                    // clz

private

只能在声明该属性的类中访问，即也不能被子类访问。

实例：把上面的例子中，name的修饰符变成private即可。

b6017eab0cd7441ab50bbf46a62a5573~tplv-k3u1fbpfcp-zoom-1.image

protected

和private类似，不过，能被子类访问

8f4d4f6a323a440cb046a196987d9cc4~tplv-k3u1fbpfcp-zoom-1.image

访问修饰符和readonly修饰符能够直接使用在构造函数的参数中。相当于在类中定义该属性的同时赋值。只读属性的用法在对象那一节已经介绍过了。

class Person {
    public name;
    public constructor(name) {
        this.name = name
    }
}

使用参数属性的简洁版：

class Person {
    public constructor(public name) { }
}

另外，如果需要同时使用访问修饰符和readonly修饰符的话，访问修饰符要在readonly修饰符之前，如public readonly name。

abstract用于定义抽象类和其中的抽象方法。对一个学过Java的人来说，就是面向对象这一块，TS和Java感觉上就是一样的。

抽象类主要是一些没有足够信息来描绘一个具体的对象的类。所以抽象类必须被继承获取足够信息，才能被使用。抽象类不能被实例化对象，但是类的其他功能依然存在。

ab74d74dbf04439b85f657d5d15ac118~tplv-k3u1fbpfcp-zoom-1.image

抽象类的使用：

abstract class Person {
    public constructor(public name) { }
}

class Student extends Person {
    public grade;
    public constructor(name, grade) {
        super(name)
        this.grade = grade
    }
}


const student = new Student('clz', 3)
console.log(student)    // Student {name: 'clz', grade: 3}

抽象类还可以有抽象方法，抽象方法只能出现在抽象类中，子类必须实现抽象方法

abstract class Person {
    public constructor(public name) { }

public abstract listen()
}

class Student extends Person {
    public grade;
    public constructor(name, grade) {
        super(name)
        this.grade = grade
    }

// public listen() {
    //     console.log('Kylee-大好きなのに')
    // }
}


const student = new Student('clz', 3)
student.listen()    // Kylee-大好きなのに

c00e500131344231b674432523f7c9e9~tplv-k3u1fbpfcp-zoom-1.image

类限制变量、函数类型

class Person {
    public name: string;
    public constructor(name: string) {
        this.name = name
    }

getName(): string {
        return this.name
    }
}


const person = new Person('clz')
console.log(person.getName())   // clz

一般来说，一个类只能继承自另一个类。(C++可以多继承)

但是，有时候不同类之间有一些共有特性，可以将它们封装成接口。

类实现接口

就拿前面的Person类举例子，所有人都需要吃、睡，即可以封装一个Normal接口，包含必须的行为。然后通过implements关键字去实现接口。接口只是声明，需要类通过implements关键字实现

interface Normal {
    eat(): void
    sleep(): void
}

class Person implements Normal {
    public name: string;
    public constructor(name: string) {
        this.name = name
    }

eat() {
        console.log('吃')
    }

sleep() {
        console.log('睡')
    }
}


const person = new Person('clz')

person.eat()    // 吃

类实现多个接口

还可以把Normal接口分解成Eat接口和Sleep接口，然后同时实现两个接口。

interface Eat {
    eat(): void
}

interface Sleep {
    sleep(): void
}

class Person implements Eat, Sleep {}

上面的Person类中省略了代码，代码和Normal接口的案例一样。

接口继承接口

类可以继承类，接口也可以继承接口。
类只能继承一个类，但是接口可以继承多个接口

interface Eat {
    eat(): void
}

interface Drink {
    drink(): void
}

interface Sleep {
    sleep(): void
}

interface Normal extends Eat, Drink, Sleep { }

攀爬TS之路(七) 类与接口

攀爬TS之路(七) 类与接口

访问修饰符

public

private

protected

类限制变量、函数类型

类实现接口

类实现多个接口

接口继承接口

Recommend

攀爬天梯的手机厂商，能从LG的滑落中学到什么？

苏宁易购向上攀爬

攀爬TS之路(三) 数组类型、元组类型

攀爬TS之路(一) 原始数据类型、任意值类型

攀爬TS之路(八) 泛型

攀爬TS之路(六) 类型别名、字面量类型、枚举

攀爬TS之路(二) 联合类型、对象类型

攀爬TS之路(四) 函数类型

攀爬TS之路(五) 类型断言

上海攀爬人工智能高地这五年|人工智能|上海市_新浪科技_新浪网

About Joyk