类的依赖处理

最新推荐文章于 2022-11-20 10:41:49 发布

原创最新推荐文章于 2022-11-20 10:41:49 发布 · 172 阅读

0 ·

CC 4.0 BY-SA版权

前端基础专栏收录该内容

26 篇文章

订阅专栏

博客主要探讨类的依赖处理，使用 TypeScript 示例代码。介绍了三种处理方式，不采用接口存在类间强耦合问题；采用接口时，客户端会用到自己用不到的方法；还提及了采用接口隔离的方式，但未详述其优缺点。

参考: https://blog.youkuaiyun.com/m0_37450089/article/details/81607363

类的依赖处理

示例代码用ts

一、不采用接口

class Car {
    constructor() {
        this.ligng = new Light()
        this.engin = new Engin()
    }

    // 刹车
    brake() {
        this.light.blink()
        this.engine.stop()
    }
}

// 车灯
class Light {
    blink() {
        console.error('刹车灯闪烁...')
    }
}

// 车发动机
class Engine {
    stop() {
        console.error('发动机熄火...')
    }
}

let car = new Car()
car.brake()

缺点:

类之间强耦合

二、采用接口

interface StopInerface {
    // 引擎熄火
    stop(): void
    // 刹车灯闪烁
    blink(): void
}

class Car {
    // 刹车
    brake(i: StopInerface) {
        i.blink()
        i.stop()
    }
}

class Light implements StopInerface{
    constructor() {}

    blink() {
        console.error('刹车灯闪烁...')
    }

    // 必须实现接口
    stop() {}
}

class Engine implements StopInterface{
    // 必须实现接口
    blink() {}

    stop() {
        console.error('发动机熄火...')
    }
}

let car = new Car()
let light = new Light()
let engine = new Engine()
car.brake({
        blink: light.blink,
        stop: engine.stop
    })

缺点:

客户端使用自己用不到的方法

三、采用接口隔离


interface LightStopInerface {
    blink(): void
}

interface EngineStopInterface {
    stop(): void
}

class Car {
    constructor() {}

    // 刹车
    brake(light: LightStopInerface, engine: EngineStopInterface) {
        light.blink()
        engine.stop()
    }
}

class Light implements LightStopInerface{
    constructor() {}

    blink() {
        console.error('刹车灯闪烁...')
    }
}

class Engine implements EngineStopInterface{
    constructor() {}

    stop() {
        console.error('发动机熄火...')
    }
}

let car = new Car()
let light = new Light()
let engine = new Engine()
car.brake({blink: light.blink}, {stop: engine.stop})