TypeScript面向对象 02

抽象类

以abstract开头的类是抽象类。抽象类和其他类区别不大，只是不能用来创建对象。抽象类就是专门用来被继承的类。

抽象类中可以添加抽象方法。定义一个抽象方法使用abstract，没有方法体。抽象方法只能定义在抽象类中，子类必须对抽象方法进行重写。

// 抽象类
abstract class Person {
    name:string;
    age:number;
    constructor(name:string, age:number) {
        this.name = name;
        this.age = age;
    }
    // 抽象方法，注意用 void 
    abstract say():void;
}
class Student extends Person {
    uid:string;
    constructor(name:string, age:number, uid:string) {
        super(name, age);
        this.uid = uid;
    }
    info() {
        console.log("学生：" + this.name);
    }
    // 子类必须重写父类中的抽象方法
    say() {
        // super.say();
        console.log("this is Child_Class");

    }
}
const stu = new Student('glm', 14, "2345");
stu.say();

接口

接口用来定义一个类结构。接口可以在定义类类的时候去限制类的结构。

• 接口中的所有属性都不能有实际的值
• 接口只定义对象的结构，而不考虑实际值
• 在接口中的所有方法都是抽象方法

interface myInter {
    name:string;
    say():void;
}
/**
 * 定义类时，可以使类去实现一个接口
 *      实现接口就是使类满足接口的要求
 */
class MyClass implements myInter {
    name:string;
    constructor(name:string) {
        this.name = name;
    }
    say() {
        console.log("hello");
    }
}

属性封装

TS可以在属性前添加属性修饰符。

• public：修饰的属性可以在任意位置访问（修改）默认值
• private：只能在类内部进行访问（修改）
  • 通过在类中添加方法使得私有属性可以被外部访问
• protected：受保护的属性，只能在当前类和当前类的子类中被访问（修改）

TS封装有两种，一种是编程语言中常见的getter/setter；另一种是TS特有的。

getter/setter

• getter：读取属性
• setter：设置属性

class Student {
    private _name:string;
    private _age:number;
    constructor(name:string, age:number) {
        this._name = name;
        this._age = age;
    }

    getName() {
        return this._name;
    }
    setName(name:string) {
        this._name = name;
    }
    getAge() {
        return this._age;
    }
    setAge(age:number) {
        this._age = age;
    }
}
const a = new Student('golemon', 321);
console.log(a.getName(), a.getAge())
a.setName('haper');
console.log(a.getName());

TS特有的封装方式

设置getter方法的方式：

get attri_name() {
	// ...
}

设置setter方法的方式：

set attri_name(val) {
	// ...
}

访问是直接通过attri_name访问，无需括号()。

class Student {
    private _name:string;
    private _age:number;
    constructor(name:string, age:number) {
        this._name = name;
        this._age = age;
    }

    get name() {
        return this._name;
    }
    set name(name:string) {
        this._name = name;
    }
    get age() {
        return this._age;
    }
    set age(age:number) {
        this._age = age;
    }
}
const a = new Student('golemon', 321);
console.log(a.name, a.age)
a.name = 'yh'
console.log(a.name);

同时，可以不用在类中声明变量，可直接在构造函数中声明。

class Class {
	constructor(public name:string, public age:number) {
		// ....
	}
}