自表达代码的特点

自表达代码的的特点

1. 代码的返回值意思明确

看一个报名程序的书写，这是采用非自表达方式书写的。

public String registerLesson(int userId, int lessonId) {
    int code = checkUserId(userId);
    if (code != 0) {
        return "user does not exist.";
    }

    code = checkLessonId(lessonId);
    if (code != 0) {
        return "lesson does not exist.";
    }

    code = checkLessonExpired(lessonId);
    if (code != 0) {
        return "lesson is expired.";
    }

    code = checkLessonVacance(lessonId);
    if (code != 0) {
        return "lesson has no vacance.";
    }

    code = registerLessonRemote(userId, lessonId);
    if (code != 0) {
        return "failed to register lesson.";
    }
    return "";
}

 

上述代码在阅读方面有如下问题：
1. code变量的意思在不停的变化。

2. 返回值的String类型在上层很难使用。

这段代码改为自表达方式书写是如下形式：

public void registerLesson(int userId, int lessonId) throws BusinessException {
    checkUserId(userId);
    checkLessonId(lessonId);
    checkLessonExpired(lessonId);
    checkLessonVacance(lessonId);
    registerLessonRemote(userId, lessonId);
}

这两种代码的书写方式的差别很明显，自表达的方式有如下优点

1. 没有局部变量

2. 代码不需要返回值

3. 方法签名的异常对上层调用来说很方便。

 

2. 基本不需要注释

代码需要注释的原因是因为代码的名称和参数不容易理解。比如 (a+ b) >>> 1;意思不是很容易理解。

自表达代码主张代码的书写本身就是自己的意思。这也正是自表达代码的意思由来。

自表达代码阅读起来就像读小说一样，就植物大战僵尸为例：

public abstract class Plant {
    public Weapon weapon;
    public Health health;

    public void fire() {
         weapon.fire();
    }
}

而武器的定义：

public abstract class Weapon {
    public Bullet bullet;
    public void fire() {
         GameWorld.getInstance.append(bullet);
    }
}

如此这般，代码基本上不需要注释就很容易明白。

 

3. 代码结构清晰

比如，书写一个Android输入法的时候，需要判定输入方式的语言类型：Hiragana,Full-Katakana,Half-Katakana, Full-Alphabet, Half-Alphabet, Half-Number。而且需要考虑输入的键盘类型，QWERTY键盘，Kana键盘，12键键盘。

那么在判定一个输入的时候代码会写成这样：

public boolean onKey(int primaryCode) {
    String keyChar ="";
    if (keyMode = QWERTY) {
         keyChar = getQwertChar(primaryCode);
    } else if (keyMode == JAPANESE_50) {
         keyChar = getJapanese50Char(primaryCode);
    } else if (keyMode == NUMBER) {
         keyChar = getNumberChar(primaryCode);
    }
    appendComposingChar(keyChar);
}

上述代码中的每个方法都要判定当前的语言类型，例如：

public String getJapanese50Char(int primaryCode) {
    switch (language) {
    case HIRAGANA:
    return HIRAGANA_TABLE[primaryode];
    case FULL_KATAKANA:
    return FULL_KATAKANA[primaryCode];
    case HALF_KATAKANA:
    return HALF_KATAKANA[primaryCode];
    case FULL_ALPHABET:
    return FULL_ALPHABET[primaryCode];
    case HALF_ALPHABET:
    return HALF_ALPHABET[primaryCode];
    case HALF_NUMBER:
    return HALF_NUMBER[primaryCode];
    }
}

同样，其他的方法也要如此的写。

但是当键盘上的键按下时，并不是组装候选文字的情况，代码需要继续扩展。到处都会是重复和类似。

简单的改写如下：

public interface Language {
    String getKey(int primaryCode);
}

public Hiragana implements Language {
    public String getKey(int primaryCode) {
         return HIRAGANA[primaryCode];
    }
}

这会让代码能够具备更好的扩展性。
并且分层清晰，让代码更容易理解。