面试题：TypeScript 接口与抽象类在复杂业务逻辑分层架构中的运用

设计思路

接口定义：
- 针对每个模块的核心概念定义接口，这些接口将作为不同模块之间交互的契约，确保模块之间的解耦。例如，定义User接口描述用户的通用属性和行为，Product接口描述商品的通用属性和行为，Order接口描述订单的通用属性和行为。
- 对于不同类型的用户、商品和订单状态，通过接口扩展来细化。比如NormalUser接口继承自User接口，增加普通用户特有的属性或行为；ElectronicProduct接口继承自Product接口，增加电子产品特有的属性或行为；PendingOrder接口继承自Order接口，增加待支付订单特有的属性或行为。
抽象类实现：
- 创建抽象类来实现部分通用逻辑。例如，创建AbstractUser抽象类实现User接口的部分通用方法，具体的用户类型（如NormalUser、MemberUser）继承自AbstractUser抽象类，并根据自身需求实现剩余的抽象方法。同样，创建AbstractProduct抽象类和AbstractOrder抽象类来处理商品和订单模块的通用逻辑。

关键代码结构

用户模块：

// 用户接口
interface User {
    id: number;
    name: string;
    email: string;
    // 其他通用用户方法
    getInfo(): string;
}

// 抽象用户类
abstract class AbstractUser implements User {
    constructor(public id: number, public name: string, public email: string) {}

    abstract getInfo(): string;
}

// 普通用户接口扩展
interface NormalUser extends User {
    // 普通用户特有属性
    registrationDate: Date;
}

// 普通用户类
class NormalUser extends AbstractUser implements NormalUser {
    constructor(id: number, name: string, email: string, public registrationDate: Date) {
        super(id, name, email);
    }

    getInfo(): string {
        return `Normal User: ${this.name}, ${this.email}, Registered on ${this.registrationDate}`;
    }
}

// 会员用户接口扩展
interface MemberUser extends User {
    // 会员用户特有属性
    membershipLevel: string;
}

// 会员用户类
class MemberUser extends AbstractUser implements MemberUser {
    constructor(id: number, name: string, email: string, public membershipLevel: string) {
        super(id, name, email);
    }

    getInfo(): string {
        return `Member User: ${this.name}, ${this.email}, Membership Level: ${this.membershipLevel}`;
    }
}

商品模块：

// 商品接口
interface Product {
    id: number;
    name: string;
    price: number;
    // 其他通用商品方法
    getDetails(): string;
}

// 抽象商品类
abstract class AbstractProduct implements Product {
    constructor(public id: number, public name: string, public price: number) {}

    abstract getDetails(): string;
}

// 电子产品接口扩展
interface ElectronicProduct extends Product {
    // 电子产品特有属性
    brand: string;
}

// 电子产品类
class ElectronicProduct extends AbstractProduct implements ElectronicProduct {
    constructor(id: number, name: string, price: number, public brand: string) {
        super(id, name, price);
    }

    getDetails(): string {
        return `Electronic Product: ${this.name}, Brand: ${this.brand}, Price: ${this.price}`;
    }
}

// 服装接口扩展
interface Clothing extends Product {
    // 服装特有属性
    size: string;
}

// 服装类
class Clothing extends AbstractProduct implements Clothing {
    constructor(id: number, name: string, price: number, public size: string) {
        super(id, name, price);
    }

    getDetails(): string {
        return `Clothing: ${this.name}, Size: ${this.size}, Price: ${this.price}`;
    }
}

订单模块：

// 订单接口
interface Order {
    id: number;
    userId: number;
    productIds: number[];
    // 其他通用订单方法
    getOrderStatus(): string;
}

// 抽象订单类
abstract class AbstractOrder implements Order {
    constructor(public id: number, public userId: number, public productIds: number[]) {}

    abstract getOrderStatus(): string;
}

// 待支付订单接口扩展
interface PendingOrder extends Order {
    // 待支付订单特有属性
    paymentDueDate: Date;
}

// 待支付订单类
class PendingOrder extends AbstractOrder implements PendingOrder {
    constructor(id: number, userId: number, productIds: number[], public paymentDueDate: Date) {
        super(id, userId, productIds);
    }

    getOrderStatus(): string {
        return `Pending Order, Payment Due on ${this.paymentDueDate}`;
    }
}

// 已支付订单接口扩展
interface PaidOrder extends Order {
    // 已支付订单特有属性
    paymentDate: Date;
}

// 已支付订单类
class PaidOrder extends AbstractOrder implements PaidOrder {
    constructor(id: number, userId: number, productIds: number[], public paymentDate: Date) {
        super(id, userId, productIds);
    }

    getOrderStatus(): string {
        return `Paid Order, Payment Date: ${this.paymentDate}`;
    }
}

// 已发货订单接口扩展
interface ShippedOrder extends Order {
    // 已发货订单特有属性
    shippingDate: Date;
}

// 已发货订单类
class ShippedOrder extends AbstractOrder implements ShippedOrder {
    constructor(id: number, userId: number, productIds: number[], public shippingDate: Date) {
        super(id, userId, productIds);
    }

    getOrderStatus(): string {
        return `Shipped Order, Shipping Date: ${this.shippingDate}`;
    }
}

通过以上分层设计，每个模块都通过接口定义了清晰的边界，抽象类实现了部分通用逻辑，不同类型的用户、商品和订单通过继承和接口扩展实现了复用和解耦。

星途面试题库

面试题：TypeScript 接口与抽象类在复杂业务逻辑分层架构中的运用

知识考点

面试题答案

设计思路

关键代码结构