TypeScript中类的使用

类的使用

typescript中类的概念和java以及es6中的基本一样，没什么区别，上例子。

1.类的定义及使用

class Person {
    name = "小黑";
    age = 18;
    say() {
        return "我叫" + this.name
    }
}
const p = new Person();
console.log(p.say());

2.类的继承

子类继承父类的所有属性及方法，并且可以直接调用。

class Student extends Person{
    work(){
        return "淦！我是学生，我得学习。"
    }
}
const S = new Student();
console.log(S.say())
console.log(S.work())

3.类的重写以及super关键字的使用

子类可以重写父类中的方法，写法就是把父类中的方法重新写一遍，其中如果我们需要调用父类中的属性，那么我们可以通过super关键字进行调用。

class Student extends Person{
    work(){
        return "淦！我是学生，我得学习。"
    }
    // 重写父类中的say()方法
    say(){
        return super.say() + "很高兴认识你！"
    }
}
const S = new Student();
console.log(S.say())
console.log(S.work())

4.类的访问类型以及只读属性

类的访问类型有public、private、protected

public

typescript默认的访问类型，如果你在写代码的时候没有声明访问类型，那么typescript会默认为public类型。
public访问类型在类的内部外部都能使用，例如我们在类的内部声明了一个变量，我们在类的外部就可以直接调用该变量，也可以修改此变量

class Person{
    public name:string;
    public say(){
        console.log(this.name)
    }
}
const p = new Person();
p.say() //第一次
p.name = "小白"
p.say() //第二次

两次的输出结果表明类的内部变量被外部操作修改了。

private

私有类型，和上面的public正好相反，可以这么理解，只要出了class的大括号，没有任何操作能直接调用他（注意这里是直接调用，后面我们会有操作私有类型的方法），这里就不给大家演示例子了。

protected

保护类型，此类型和private差不多，都是出了大括号就不能直接操作，但是protected允许在继承时被操作

class Person{
    protected name:string;
    public say(){
        console.log(this.name)
    }
}
class Student extends Person{
    name = "小黑";
    sayHello(){
        console.log(this.name)
    }
}
const p = new Student();
p.say()
p.sayHello()

只读属性readonly

在类中声明变量时可以定义变量的类型，其中有一个属性叫readonly只读属性，加上此属性的变量在尝试改变其值的时候会报错。

class Person{
	public readonly name: string;
}

5.类的构造函数

普通的构造函数

typescript的类中有一个constructor方法，也就是我们的构造函数，我们可以使用这个方法对类进行初始化，而且typescript中的constructor写起来很方便，具体如下：

class Person {
    constructor(private name: string, public age: number) { }
}
const p = new Person("小黑", 21)
// console.log(p.name);     //这里记得name是私有变量，外部不能直接调用
console.log(p.age)

子类的构造函数

子类的构造函数比较特殊，由于进行了一次继承extends操作，所以我们在子类中写构造函数的时候必须使用super()，否则typescript会报错。

class Student extends Person {
    constructor(private exam: number) { 
        super("小白",18);
    }
}

6.类的setter和getter

在开发过程中，为了保证数据的安全性我们往往会把数据定义private，如果想要调用就会用到**setter()方法与getter()**方法或者构造函数方法。

class Person {
    constructor(private name: string, private age: number) { }
    get getName() {
        return this.name
    }
    set setName(name: string) {
        this.name = name
    }
    get getAge() {
        return this.age
    }
    set setAge(age: number) {
        this.age = age
    }
}
const p = new Person("小黑", 21)
p.setName = "小白"
console.log(p.getName)

7.抽象类的使用

抽象类abstract的引入能便于我们规范类的编写，上例子：
比如我们进出学校都需要报备自己是那个单位（班级）的。

abstract class School{
    // 抽象类中的方法都需要加上abstract关键字，表示抽象方法
    abstract baobei()
}
class Student extends School{
    // 继承了抽象方法的类都必须对父类中的抽象方法进行具体化，具体跟类的重写是一样的
    baobei(){
        console.log("我是学生，是xx班的")
    }
}