请求将迪米特法则论文中的旧版Lisp代码转译为主流编程语言

第一处代码（违反迪米特法则的坏示例） #

这段Lisp代码定义了类A的:bad-style方法，逻辑是：调用自身的:first方法获取对象，再调用该对象的:sixth方法获取下一个对象，最后调用这个对象的:seventh方法。这种连续操作间接对象的写法，违反了迪米特法则（最少知道原则）。

Java 实现 #

class A {
    // 假设存在返回对应对象的方法
    private First getFirst() { /* 实现逻辑 */ }

    public void badStyle() {
        // 连续调用间接对象方法，违反迪米特法则
        getFirst().getSixth().seventh();
    }
}

// 辅助类（保证代码完整性）
class First {
    private Sixth getSixth() { /* 实现逻辑 */ }
}

class Sixth {
    public void seventh() { /* 实现逻辑 */ }
}

TypeScript 实现 #

class A {
    // 假设存在返回对应对象的方法
    private getFirst(): First { /* 实现逻辑 */ }

    badStyle(): void {
        this.getFirst().getSixth().seventh();
    }
}

class First {
    private getSixth(): Sixth { /* 实现逻辑 */ }
}

class Sixth {
    seventh(): void { /* 实现逻辑 */ }
}

Dart 实现 #

class A {
    // 假设存在返回对应对象的方法
    First _getFirst() { /* 实现逻辑 */ }

    void badStyle() {
        _getFirst().getSixth().seventh();
    }
}

class First {
    Sixth _getSixth() { /* 实现逻辑 */ }
}

class Sixth {
    void seventh() { /* 实现逻辑 */ }
}

第二处代码（迪米特法则相关示例） #

注释里的A = <x> B表示类A包含类型为B的成员x；T = <x> B表示类T包含类型为B的成员x。这段代码定义了两个方法：

1. 类A的:alias方法：接收参数t，将自身的x设置为t的x
2. 类T的:m2方法：接收参数a，调用a的x成员的:m3方法（直接访问内部成员，违反迪米特法则）

Java 实现 #

class A {
    private B x;

    // 将自身x设置为参数t的x
    public void alias(T t) {
        this.x = t.getX();
    }

    public B getX() {
        return x;
    }

    // 符合迪米特法则的改进：封装内部调用，避免外部直接访问x
    public void callXM3() {
        if (x != null) {
            x.m3();
        }
    }
}

class T {
    private B x;

    // 违反迪米特法则：直接访问a的内部成员
    public void m2(A a) {
        a.getX().m3();
    }

    // 改进后：调用A提供的封装方法
    public void m2Improved(A a) {
        a.callXM3();
    }

    public B getX() {
        return x;
    }
}

class B {
    public void m3() { /* 实现逻辑 */ }
}

TypeScript 实现 #

class A {
    private x: B | undefined;

    alias(t: T): void {
        this.x = t.getX();
    }

    getX(): B | undefined {
        return this.x;
    }

    // 符合迪米特法则的封装方法
    callXM3(): void {
        this.x?.m3();
    }
}

class T {
    private x: B | undefined;

    // 违反迪米特法则的写法
    m2(a: A): void {
        a.getX()?.m3();
    }

    // 改进后的写法
    m2Improved(a: A): void {
        a.callXM3();
    }

    getX(): B | undefined {
        return this.x;
    }
}

class B {
    m3(): void { /* 实现逻辑 */ }
}

Dart 实现 #

class A {
    B? _x;

    void alias(T t) {
        _x = t.getX();
    }

    B? getX() {
        return _x;
    }

    // 符合迪米特法则的封装方法
    void callXM3() {
        _x?.m3();
    }
}

class T {
    B? _x;

    // 违反迪米特法则的写法
    void m2(A a) {
        a.getX()?.m3();
    }

    // 改进后的写法
    void m2Improved(A a) {
        a.callXM3();
    }

    B? getX() {
        return _x;
    }
}

class B {
    void m3() { /* 实现逻辑 */ }
}

内容的提问来源于stack exchange，提问作者Ced