继承
继承是⾯向对象编程中的重要机制，允许⼀个类（⼦类或派⽣类）继承另⼀个类（⽗类或基类）的属性和⽅法。⼦类可以直接使⽤⽗类的特性，并根据需要添加新的特性或覆盖现有的特性。这种机制赋予⾯向对象程序良好的扩展性。
下⾯通过⼀个例⼦演⽰继承的特性：
class Student extends Person {
classNumber: string;
constructer(id:number, name: string, classNumber: string) {
super(id,name);
this.classNumber = classNumber;
}
introduce(): string {
return super.introduce() + `, and I am a student`;
}
}
let student = new Student(1, 'xiaoming','三年二班');
console.log(student.introduce());注意：
类的继承需要使用关键字extends
子类构造器中需使用super（）调用父类构造器对继承自父类的属性进行初始化。
在子类可以使用this关键字访问继承自父类的属性和方法
在子类中可以使用super关键字访问父类定义的方法
访问修饰符
访问修饰符（Access Modifiers）⽤于控制类成员（属性、⽅法等）的可访问性。TypeScript提供了三种访问修饰符，分别是private、protected和public。
class Person {
private id: number;
protected name: string;
public age: number;
constructor(id: number, name: string, age: number) {
this.id = id;
this.name = name;
this.age = age;
}
}
class Student extends Person {
}说明：
private 修饰的属性或方法是私有的，只能在声明它的类中被访问
protected修饰的属性或方法是受保护的，只能在声明它的类和其子类中被访问。
public修饰的属性或方法是公有的，可以在任何地方被访问到，默认所有的属性和方法都是public的
接口（interface）
接口（interface）是面向对象编程中的另一个重要概念。接口通常会作为一种契约或规范让类（class）去遵守，确保类实现某些特定的行为或功能。
语法说明
接⼝定义
接⼝使⽤
interface
关键字定义，通常情况下，接⼝中只会包含属性和⽅法的声明，⽽不包含具体
的实现细节，具体的细节由其实现类完成。
interface Person {
id: number;
name: string;
age: number;
introduce(): void;
} 接口实现
接⼝的实现需要⽤到
implements
关键字，实现类中，需要包含接⼝属性的赋值逻辑，以及接⼝⽅
法的实现逻辑。
class Student implements Person {
id: number;
name: string;
age: number;
constructor(id: number,name: string, age: number) {
this.id = id;
this.name = name;
this.age = age;
}
introduce(): void {
console.log('Hello,I am a student');
}
}
多态
多态是⾯相对象编程中的⼀个重要概念，它可以使同⼀类型的对象具有不同的⾏为。下⾯我们通过⼀个具体的案例来体会多态这⼀概念.
⾸先，再创建⼀个
Person
接⼝的实现类
Teacher
，如下:
class Teacher implements Person {
id: number;
name: string;
age: number;
constructor(id: number,name: string, age: number) {
this.id = id;
this.name = name;
this.age = age;
}
introduce(): void {
console.log('Hello,I am a Teacher');
}
}然后分别创建一个Student对象和⼀个 Teacher 对象，注意两个对象的类型均可以设置Person ，如下：
let p1: Person = new Student(1, 'zhangsan', 17);
let p2: Person = new Teacher(2, 'list', 35)
最后分别调⽤
p1
和
p2
的
introduce()
⽅法，你会发现，同样是
Person
类型的两个对象，调⽤同⼀个 introduce()
⽅法时，表现出了不同的⾏为，这就是多态。
p1.introduce(); //Hello, I am a student
p2.introduce(); //Hello, I am a teacher接口的作用（重点！！！）
在传统的⾯向对象编程的场景中，接⼝主要⽤于设计和组织代码，使代码更加容易扩展和维护。下⾯举例说明。
假如现在需要实现⼀个订单⽀付系统，按照⾯向对象编程的习惯，⾸先需要定义⼀个订单类
（Order），如下 ：
class Order {
totalAmount: number;
constructor(totalAmount: number) {
this.totalAmount = totalAmount;
}
pay() {
console.log(`AliPay: ${this.totalAmount}`);
}
}
很容易预想到，这个系统将来可能需要⽀持其他的⽀付⽅式，为了⽅便代码⽀持新的⽀付⽅式，我们可以对代码进⾏如下改造。‘
⾸先定义⼀个⽀付策略的接⼝，接⼝中声明⼀个 pay ⽅法，⽤来规范实现类必须实现⽀付逻辑。
interface PaymentStrategy {
pay(amount: number): void;
}
然后在订单类中增加⼀个 PaymentStrategy 的属性，并且在订单类中的 pay ⽅法中调⽤
PaymentStrategy 的 pay ⽅法，如下
class Order {
totalAmount: number;
paymentStrategy: PaymentStrategy;
constructor(totalAmount: number,paymentStrategy: PaymentStrategy) {
this.totalAmount = totalAmount;
this.paymentStrategy = paymentStrategy;
}
pay() {
this.paymentStrategy.pay(this.totalAmount);
}
}这样改造完之后，就可以很容易的在不改变现有代码的情况下，支持新的支付方式了。
⽐如现在需要⽀持 AliPay ，那我们就可以创建 AliPay 这个类（class）并实现（implement）
PaymentStrategy 这个接⼝，如下
class AliPay implements PaymentStrategy {
pay(amount: number): void {
console.log(`AliPay:${amount}`);
}
}
这样⼀来，之后创建的订单就可以使⽤
AliPay
这个⽀付⽅式了。
let order = new Order(1000,new AliPay());
order.pay();稍等
就上面的代码我要讲一下。
this.paymentStrategy.pay(this.totalAmount) 是什么意思？
它就是利用当前订单对象所持有的支付策略对象来处理支付操作。使用策略模式的好处在于，可以将支付逻辑与订单对象的其他功能分离开来。
TS中的接口的特殊性
TypeScript中的接口是一个⾮常灵活的概念，除了⽤作类的规范之外，也常⽤于直接描述对象的类型，例如，现有⼀个变量的定义如下：
let person: {name:string, age:number, gender:string} = {name:'张三', age:10, gender:'男'}；
⾮常灵活的概念，除了⽤作类的规范之外，也常⽤于直接描述对象的类型，例如，现有⼀个变量的定义如下：
interface Person {
name: sting;
age: number;
gender: string;
}
let person: Person = {name:'张三', age:10, gender:'男'};
