“Effective Java” 可能对 Kotlin 的设计造成了怎样的影响——第一部分

简评：作者从《Effective Java》中选出了几条项目，举例分析 Java 和 Kotlin 写法不同之处，Kotlin 从中得到启发，写法更加简洁。

Java 是一种很好的语言但是有些众所周知的瑕疵，常见的陷阱以及早期（1.0 在 1995 年发布）继承过来的不是很好的元素。一本备受推崇的关于如何写好 Java 代码的书，避免常见的编码失误，处理它的弱点的书就是 Joshua Bloch 的《Effective Java》。它包含 78 个部分，为读者提供有关语言不同方面的宝贵意见。

现代编程语言的创造者有个很大的优势，因为它们可以分析已经创立的语言的弱点，从而改进它们。Jetbrains，创建了几款非常流行的 IDE 的公司，在 2010 年决定创建 Kotlin 编程语言作为自己的开发语言。它的目标是更简洁和更清晰的表达，同时消除Java的一些弱点。他们之前写 IDE 的代码都是用 Java 写的，所以他们需要一种与 Java 高度互操作的语言，并编译成Java 字节码。他们也想要 Java 开发者非常容易上手 Kotlin。使用 Kotlin，Jetbrains 想要构建更好的 Java。

1. 使用 Kotlin 的默认值，不再需要 builder 模式

当你在 Java 的构造器中有很多可选的参数时，代码就会变得冗长，难读而且容易出错。为了避免这种情况，《Effective Java》的第二条项目描述了如何高效使用 Builder 模式。构建这样的对象需要很多代码，比如下面的营养成分对象代码示例。它需要两个必需参数(servingSize, servings) 以及四个可选参数 ( calories, fat, sodium, carbohydrates):

public class JavaNutritionFacts {
    private final int servingSize;
    private final int servings;
    private final int calories;
    private final int fat;
    private final int sodium;
    private final int carbohydrate;

    public static class Builder {
        // Required parameters
        private final int servingSize;
        private final int servings;

        // Optional parameters - initialized to default values
        private int calories      = 0;
        private int fat           = 0;
        private int carbohydrate  = 0;
        private int sodium        = 0;

        public Builder(int servingSize, int servings) {
            this.servingSize = servingSize;
            this.servings    = servings;
        }

        public Builder calories(int val)
        { calories = val;      return this; }
        public Builder fat(int val)
        { fat = val;           return this; }
        public Builder carbohydrate(int val)
        { carbohydrate = val;  return this; }
        public Builder sodium(int val)
        { sodium = val;        return this; }

        public JavaNutritionFacts build() {
            return new JavaNutritionFacts(this);
        }
    }

    private JavaNutritionFacts(Builder builder) {
        servingSize  = builder.servingSize;
        servings     = builder.servings;
        calories     = builder.calories;
        fat          = builder.fat;
        sodium       = builder.sodium;
        carbohydrate = builder.carbohydrate;
    }
}

使用 Java 代码来实例化对象看起来像这样：

final JavaNutritionFacts cocaCola = new JavaNutritionFacts.Builder(240,8)
    .calories(100)
    .sodium(35)
    .carbohydrate(27)
    .build();

使用 Kotlin 你根本不需要使用 Builder 模式，因为它有默认参数的功能，允许你定义每个可选构造器参数的默认值。

class KotlinNutritionFacts(
        private val servingSize: Int,
        private val servings: Int,
        private val calories: Int = 0,
        private val fat: Int = 0,
        private val sodium: Int = 0,
        private val carbohydrates: Int = 0)

创建一个 Kotlin 对象看起来像这样：

val cocaCola = KotlinNutritionFacts(240,8,
                calories = 100,
                sodium = 35,
                carbohydrates = 27)

为了更好的可读性，你也可以声明必需的参数 servingSize 和 servings：

val cocaCola = KotlinNutritionFacts(
                servingSize = 240,
                servings = 8,
                calories = 100,
                sodium = 35,
                carbohydrates = 27)

像 Java 一样，这里对象的创建是不可改变的。
我们将 Java 所需的 47 行代码减少到 Kotlin 的 7 行，生产率有很大的提高。

提示：如果你想要在 Java 中创建 KotlinNutrition 对象，你当然可以那样做，但是你被迫为每个可选参数指定一个值。幸运的是，如果你加上 JvmOverloads 注解，多种构造器就被生成了。注意如果你想要使用一个注解，我们需要声明关键词 constructor ：

class KotlinNutritionFacts @JvmOverloads constructor(
        private val servingSize: Int,
        private val servings: Int,
        private val calories: Int = 0,
        private val fat: Int = 0,
        private val sodium: Int = 0,
        private val carbohydrates: Int = 0)

2. 轻松创建单例

《Effective Java》的第三条建议展示了将一个 Java 对象设计成单例，意味着只有一个实例能被实例化。下面的代码片段显示了 “ monoelvistic” 宇宙，只有一个 Elvis 存在：

public class JavaElvis {

    private static JavaElvis instance;

    private JavaElvis() {}

    public static JavaElvis getInstance() {
        if (instance == null) {
            instance = new JavaElvis();
        }
        return instance;
    }

    public void leaveTheBuilding() {
    }
}

Kotlin 有对象声明的概念，给了我们一个单例行为，开箱即用：

object KotlinElvis {

    fun leaveTheBuilding() {}
}
view raw

再也不需要手动构建单例模式了！

3. equals() 和 hashCode() 开箱即用

一个良好的编程实践起源于函数编程，简化代码主要是使用不可变值对象。第 15 项就是“类应该是不可变的除非有一个非常好的理由让它们可变。”不可变值对象在 Java 中的创建非常乏味，因为每一个对象你都要重写 equals() 和 hashCode() 方法。这在第 8 和第 9 项中花费了 Joshua Bloch 18 页来描述如何遵循这一详尽的普遍的准则。例如，如果你重写 equals()，则必须确保灵活性，对称性，传递性，一致性和无效性的合同都得到满足。听起来更像数学而不是编程。

在 Kotlin 中，你只要使用 data 类即可。编译器自动导出像 equals() 和 hashCode() 等方法。这是可能的，因为标准函数可以从对象的属性机械地派生。只要在你的类前面输入关键字 data 即可。不需要 18 页的描述了。

提示：最近 AutoValue 在 Java 中变得很流行，这个库为 Java 1.6+ 生成不可变值类。

4. 属性替代字段

public class JavaPerson {

    // don't use public fields in public classes!
    public String name;
    public Integer age;
}

第 14 项建议在公共类中使用访问器方法而不是公共字段。如果你不遵循这个建议可能会有麻烦，因为如果字段可以直接访问那么就丧失了封装和灵活性带来的好处。这意味着将来你不更改其公共 API 将无法改变你的类的内部表示。例如，你无法限制字段的值，如某人的年龄等等。这是一个为什么我们总是创建冗长的 getter 和 setter 方法的原因。

最佳实践被 Kotlin 增强了，因为它使用自动生成的默认 getter 和 setter 方法的属性替代了字段。

class KotlinPerson {

    var name: String? = null
    var age: Int? = null
}

在语法上，你可以像使用 person.name 或者 person.age 访问 Java 的公共字段一样访问这些属性。你也可以自定义 getter 和 setter 方法而不需要改变类的 API：

class KotlinPerson {

    var name: String? = null

    var age: Int? = null
    set(value) {
        if (value in 0..120){
            field = value
        } else{
            throw IllegalArgumentException()
        }
    }
}

长话短说：使用 Kotlin 的属性，我们的类更加简洁也更加灵活。

5. Override 变成了强制性的关键字而不是可选的注解

注解在 Java 发布的 1.5 版本中增加了。最重要的一个就是 Override，标记着一个方法正在重写父类的方法。根据第 36 项，为了避免歹毒的 bug，可选的注解应该不断地被使用。当你认为你正在重写父类的方法而实际上没有时，编译器会抛出一个错误。只要当你没有忘记使用 Override 注解，那么就没有问题。

在 Kotlin 中，override 不再是可选的注解而是强制的关键字。所以像这类难受的 bug 不会再出现，编译器将会提前警告你。Kotlin 坚持把这些事弄清楚。

原文链接：How “Effective Java” may have influenced the design of Kotlin — Part 1

延伸阅读：

• Kotlin 让使用 Android API 变得轻松
• 极光开源项目：「Aurora UI」，一个通用 IM 聊天 UI 组件，支持Android、iOS（swift/oc）、react。