Java 语言的开发人员精通 C++ 和其他语言，包括多继承（multiple
inheritance），使得类可以继承自任意数量的父类。多继承带来的一个问题是，不可能确定所继承的功能来自哪个父类。这个问题被称为钻石问题（请参阅
参考资料）。钻石问题和多继承中固有的其他复杂性启发了 Java 语言设计者选择 “单继承加接口”
的方法。
接口定义了语义，但没有定义行为。它们非常适合用来定义方法签名和数据抽象，所有 Java 下一代语言都支持 Java
接口，并且无需进行重大的修改。不过，有些交叉问题不适合使用 “单继承加接口” 模型。这种错位导致必须提供适合 Java 语言的外部机制，比如面向方面的编程。两种
Java 下一代语言（Groovy 和 Scala）通过使用一种被称为混入 或特征 的语言结构在另一个层次的扩展上处理这类问题。本文介绍了 Groovy
中的混入和 Scala 中的特征，并演示了如何使用它们。（Clojure 通过协议处理大致相同的功能，我在 Java 下一代：没有继承性的扩展，第 2 部分
中已经介绍过这一点。）
混入
冰淇淋的灵感
混入的概念起源于 Flavors 语言（请参阅
参考资料）。这个概念的灵感来自于开发该语言的办公室附近的一家冰??淇淋店。这家冰淇淋店提供了纯口味的冰淇淋，以及客户想要的其他任何的
“混合物”（糖果碎、糖屑、坚果，等等）。
早期的一些面向对象语言在单个代码块*同定义某个类的属性和方法，所有类定义是完整的。在其他语言中，开发人员可以在一个地方定义属性，但推迟方法的定义，并在适当的时候将它们
“混合” 到类中。随着面向对象语言的演变，混入与现代语言的配合方式的细节也在演变。
在 Ruby、Groovy
和类似的语言中，作为一个接口和父类之间的交叉，混入可以扩充现有的类层次结构。像接口一样，混入可以充当 instanceof
检查的类型，同时也要遵循相同的扩展规则。您可以将无限数量的混入应用于某一个类。与接口不同的是，混入不仅指定了方法签名，也可以实现签名的行为。
在包括混入的第一种语言中，混入只包含方法，不包含状态，例如，成员变量。现在很多语言（Groovy
也在其中）都包括有状态的混入。Scala 的特征也以有状态的方式进行操作。
回页首
Groovy 的混入
Groovy 通过
metaClass.mixin() 方法或 @Mixin 注解来实现混入。（@Mixin 注解依次使用 Groovy Abstract Syntax Tree
(AST) 转换，以支持所需的元编程管道。）清单 1 中的示例使用 metaClass.mixin() 让 File 类能够创建 ZIP 压缩文件：
清单
1. 将 zip() 方法混合到 File 类中
class Zipper {
def zip(dest) {
new ZipOutputStream(new
FileOutputStream(dest))
.withStream { ZipOutputStream zos
->
eachFileRecurse { f ->
if (!f.isDirectory()) {
zos.putNextEntry(new ZipEntry(f.getPath()))
new
FileInputStream(f).withStream { s ->
zos << s
zos.closeEntry()
}
}
}
}
}
static {
File.metaClass.mixin(Zipper)
}
}
hxbylc89.com
slylc843.com
sleylc63.com
jbpylc56.com
mpylc86.com
在清单 1 中，我创建了一个 Zipper 类，它包含新的 zip() 方法，以及将该方法添加到现有 File 类的连接。zip()
方法的（不起眼的）Groovy 代码以递归方式创建了一个 ZIP 文件。清单的最后一部分通过使用静态的初始化程序，将新方法添加到现有的 File 类。在
Java 语言中，类的静态初始化程序在加载类的时候运行。静态初始化程序是扩充代码的理想位置，因为在运行依赖于增强的任何代码之前，应确保先运行初始化程序。在 清单
1 中，mixin() 方法将 zip() 方法添加到 File。
在 "没有继承性的扩展，第 1 部分" 中，我介绍了两种 Groovy 机制：
ExpandoMetaClass 和类别类，您可以使用它们在现有类上添加、更改或删除方法。使用 mixin() 添加方法的最终结果与使用
ExpandoMetaClass 或类别类添加方法的最终结果相同，但它们的实现是不一样的。请考虑清单 2 中混入示例：
清单 2.
混入操纵继承层次结构
import groovy.transform.ToString
class DebugInfo {
def getWhoAmI() {
println "${this.class} <-
${super.class.name}
<<--
${this.getClass().getSuperclass().name}"
}
}
@ToString class Person {
def name, age
}
@ToString class Employee extends Person {
def id, role
}
@ToString class Manager extends Employee {
def suiteNo
}
Person.mixin(DebugInfo)
def p = new Person(name:"Pete", age:33)
def e = new Employee(name:"Fred",
age:25, id:"FRE", role:"Manager")
def m = new Manager(name:"Burns", id:"001",
suiteNo:"1A")
p.whoAmI
e.whoAmI
m.whoAmI
在清单 2 中，我创建了一个名为 DebugInfo 的类，其中包含一个
getWhoAmI 属性定义。在该属性内，我打印出类的一些详细信息，比如当前类以及 super 和 getClass().getSuperClass()
属性的父子关系说明。接下来，我创建一个简单的类层次结构，包括 Person、Employee 和 Manager。
然后我将 DebugInfo
类混合到驻留在层次结构顶部的 Person 类。由于 Person 具有 whoAmI
属性，所以其子类也具有该属性。
在输出中，可以看到（并且可能会感到惊讶），DebugInfo 类将自己插入到继承层次结构中：
class
Person <- DebugInfo <<-- java.lang.Object
class Employee <-
DebugInfo <<-- Person
class Manager <- DebugInfo <<--
Employee
混入方法必须适应 Groovy 中现有的复杂关系，以便进行方法解析。清单 2
中的父类的不同返回值反映了这些关系。方法解析的细节不属于本文的讨论范围。但请小心处理对混入方法中的 this 和 super
值（及其各种形式）的依赖。
使用类别类或 ExpandoMetaClass
不影响继承，因为您只是对类进行修改，而不是混入不同的新行为中。这样做的一个缺点是，无法将这些更改识别为一个不同类别的构件。如果我使用类别类或
ExpandoMetaClass 将相同的三个方法添加到多个类中，那么没有特定的代码构件（比如接口或类签名）可以识别目前存在的共性。混入的优点是，Groovy
将使用混入的一切都视为一个类别。
类别类实现的一个麻烦之处在于严格的类结构。您必须完全使用静态方法，每个方法至少需要接受一个参数，以代表正在进行扩充的类型。元编程是最有用的，它可以消除这样的样板代码。@Mixin
注释的出现使得创建类别并将它们混合到类中变得更容易。清单 3（摘自 Groovy 文档）说明了类别和混入之间的协同效应：
清单 3.
结合类别和混入
interface Vehicle {
String getName()
}
@Category(Vehicle) class Flying {
def fly() { "I‘m the ${name} and I
fly!"}
}
@Category(Vehicle) class Diving {
def dive() { "I‘m the ${name} and I
dive!"}
}
@Mixin([Diving, Flying])
class JamesBondVehicle implements Vehicle {
String getName() { "James Bond‘s vehicle" }
}
assert new JamesBondVehicle().fly() ==
"I‘m the James Bond‘s
vehicle and I fly!"
assert new JamesBondVehicle().dive() ==
"I‘m
the James Bond‘s vehicle and I dive!"
在清单 3 中，我创建了一个简单的 Vehicle
接口和两个类别类（Flying 和 Diving）。@Category 注释关注样板代码的要求。在定义了类别之后，我将它们混合成一个
JamesBondVehicle，以便连接两个行为。
类别、ExpandoMetaClass 和混入在 Groovy
中的交集是积极的语言进化的必然结果。三种技术明显有重叠之处，但每种技术都有它们自身才能处理得最好的强项。如果从头重新设计
Groovy，那么作者可能会将三种技术的多个特性整合在一个机制中。