混合和继承有什么区别？

Question

我试图在 scala 的上下文中理解 Mixins。特别是我想知道继承和 Mixins 概念之间的区别。

wiki 中 Mixin 的定义说：

mixin 类充当父类，包含所需的功能。然后子类可以继承或简单地重用此功能，但不能作为专门化的手段。通常，mixin 会将所需的功能导出到子类，而不会创建严格的、单一的“是”关系。这就是 mixins 和继承概念之间的重要区别，子类仍然可以继承父类的所有特性，但是，关于子类“是一种”父类的语义不必是必须应用。

在上述定义中，我无法理解以粗体标记的陈述。这是什么意思

1. 子类可以继承 mixin 中的功能，但不能作为特化的手段
2. 在 mixins 中，子类继承了父类的所有特性，但是关于子类“成为一种”父类的语义不一定要应用。 - 孩子如何扩展父母而不一定是父母？有没有这样的例子。

Answer 1

我不确定我是否正确理解了您的问题，但如果我理解了，您是在问一些东西如何继承，而没有真正与继承相同的含义。

然而，Mixins 不是继承——它实际上更像是动态地将一组方法添加到一个对象中。继承说“这个东西是另一种东西”，mixins 说，“这个对象有这个东西的一些特征。”您可以在用于声明 mixins 的关键字中看到这一点：trait。

从 Scala 主页公然窃取示例：

abstract class Spacecraft {
  def engage(): Unit
}
trait CommandoBridge extends Spacecraft {
  def engage(): Unit = {
    for (_ <- 1 to 3)
      speedUp()
  }
  def speedUp(): Unit
}
trait PulseEngine extends Spacecraft {
  val maxPulse: Int
  var currentPulse: Int = 0
  def speedUp(): Unit = {
    if (currentPulse < maxPulse)
      currentPulse += 1
  }
}
class StarCruiser extends Spacecraft
                     with CommandoBridge
                     with PulseEngine {
  val maxPulse = 200
}

在这种情况下，StarCruiser 不是CommandoBridge 或PulseEngine；但是，它拥有它们，并获得了这些特征中定义的方法。它是Spacecraft，正如您所见，因为它继承自该类。

值得一提的是，当 trait 扩展 class 时，如果你想制作 with 的特性，它必须扩展该类。例如，如果我有一个class Dog，我不能有一个Dog with PulseEngine，除非Dog 扩展Spacecraft。这样一来，就不太像添加方法了；但是，它仍然相似。

Answer 2

trait（与类混合时称为 mixin）就像 Java 中的接口（尽管有很多 differences），您可以在其中添加额外的类的特征，而不必具有“是”关系。或者你可以说一般特征捆绑了可以被多个独立类使用的特性。

举个 Scala 库中的例子，Ordered[A] 是一个 trait，它提供了一些基本比较操作的实现（如 <、<=、>、>=）到可以具有自然排序的数据。

例如，假设您有自己的类Number 和子类EvenNumber 和OddNumber，如下所示。

class Number(val num : Int) extends Ordered[Number] {
  override def compare(that : Number) = this.num - that.num
}

trait Half extends Number {
  def half() = num / 2
}

trait Increment extends Number {
  def increment() = num + 1
}

class EvenNumber(val evenNum : Int) extends Number(evenNum) with Half

class OddNumber(val oddNum : Int) extends Number(oddNum) with Increment

在上面的示例中，EvenNumber 和 OddNumber 类与 Number 共享 是 关系，但 EvenNumber 与 Half 和 @987654337 都没有“是”关系@share “是”与 Increment 的关系。

另一个重要的一点是即使Number类使用extends Ordered语法，这意味着Number有一个隐式 是一个 与Ordered 的超类的关系，即Any。

Answer 3

我认为它非常依赖于使用。 Scala 作为一种多范式语言，使其功能强大，但有时也令人困惑。 我认为以正确的方式使用 Mixins 非常强大。 应该使用 Mixins 来引入行为并减少 bolierplate。

Scala 中的 trait 可以有实现，并且很想扩展和使用它们。

特征可用于继承。它也可以称为 mixins，但在我看来这不是使用 mixin 行为的最佳方式。在这种情况下，您可以将特征视为 Java 抽象类。其中你得到的子类是超类（特征）的“类型”。

不过，Traits 也可以用作 proper mixins。现在使用特征作为mixin 取决于“你如何混合它”的实现。主要是问自己一个简单的问题。它是“特征的子类真的是特征的kind 还是特征行为中减少样板的行为”。 通常，最好通过将特征混合到对象而不是扩展特征来创建新类来实现。

例如考虑下面的例子：

    //All future versions of DAO will extend this
trait AbstractDAO{
  def getRecords:String
  def updateRecords(records:String):Unit
}
//One concrete version
trait concreteDAO extends AbstractDAO{
  override def getRecords={"Here are records"}
  override def updateRecords(records:String){
    println("Updated "+records)
  }
}
//One concrete version
trait concreteDAO1 extends AbstractDAO{
  override def getRecords={"Records returned from DAO2"}
  override def updateRecords(records:String){
    println("Updated via DAO2"+records)
  }
}
//This trait just defines dependencies (in this case an instance of AbstractDAO) and defines operations based over that
trait service{
  this:AbstractDAO =>

  def updateRecordsViaDAO(record:String)={  
  updateRecords(record) 
  }
  def getRecordsViaDAO={
  getRecords
  }
}


object DI extends App{
  val wiredObject = new service with concreteDAO //injecting concrete DAO to the service and calling methods
  wiredObject.updateRecords("RECORD1")
  println(wiredObject.getRecords)

  val wiredObject1 = new service with concreteDAO1
  wiredObject1.updateRecords("RECORD2")
  println(wiredObject1.getRecords)

}

concreteDAO 是扩展 AbstractDAO 的特征 - 这是继承

val wiredObject = new service with concreteDAO - 这是正确的混合行为 由于服务特征要求AbstractDAO 的mixin。无论如何，Service 扩展ConcreteDAO 是错误的，因为service 需要AbstractDAO，它不是AbstractDAO 的类型。 相反，您使用不同的 mixin 创建 service 的实例。

Answer 4

mixin 和继承之间的区别在于语义级别。在语法级别上，它们都是相同的。

要混合一个特征，或者从一个特征继承，它们都使用extends 或with，这是相同的语法。

在语义级别上，打算混入的特征通常与混合它的类没有is a 关系，这与打算被继承的特征不同。

对我来说，一个 trait 是 mixin 还是 parent 是非常主观的，这通常是混淆的根源。

Answer 5

我认为这是在谈论实际的类层次结构。例如，Dog 是 Animal 的类型，如果它从类扩展（继承）。它可以在任何Animal 参数适用的地方使用。