Typescript语法二

继承

继承是⾯向对象编程中的重要机制，允许⼀个类（⼦类或派⽣类）继承另⼀个类（⽗类或基类）的属性和⽅法。⼦类可以直接使⽤⽗类的特性，并根据需要添加新的特性或覆盖现有的特性。这种机制赋予⾯向对象程序良好的扩展性。

下⾯通过⼀个例⼦演⽰继承的特性：

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:'男'};