我可以考虑两个分歧。

1. Abstract classes can have constructor parameters as well as type parameters. Traits can have only type parameters. There was some discussion that in future even traits can have constructor parameters
2. Abstract classes are fully interoperable with Java. You can call them from Java code without any wrappers. Traits are fully interoperable only if they do not contain any implementation code

在Schala的节目中,有一节称:“To trait, 或不适用于 trait?>, 涉及这一问题。 由于第1版可在网上查阅,我希望它能在这里引述全部内容。 (任何认真的Schala方案家应当购买该书):

Whenever you implement a reusable collection of behavior, you will have to decide whether you want to use a trait or an abstract class. There is no firm rule, but this section contains a few guidelines to consider.

If the behavior will not be reused, then make it a concrete class. It is not reusable behavior after all.

If it might be reused in multiple, unrelated classes, make it a trait. Only traits can be mixed into different parts of the class hierarchy.

If you want to inherit from it in Java code, use an abstract class. Since traits with code do not have a close Java analog, it tends to be awkward to inherit from a trait in a Java class. Inheriting from a Scala class, meanwhile, is exactly like inheriting from a Java class. As one exception, a Scala trait with only abstract members translates directly to a Java interface, so you should feel free to define such traits even if you expect Java code to inherit from it. See Chapter 29 for more information on working with Java and Scala together.

If you plan to distribute it in compiled form, and you expect outside groups to write classes inheriting from it, you might lean towards using an abstract class. The issue is that when a trait gains or loses a member, any classes that inherit from it must be recompiled, even if they have not changed. If outside clients will only call into the behavior, instead of inheriting from it, then using a trait is fine.

If efficiency is very important, lean towards using a class. Most Java runtimes make a virtual method invocation of a class member a faster operation than an interface method invocation. Traits get compiled to interfaces and therefore may pay a slight performance overhead. However, you should make this choice only if you know that the trait in question constitutes a performance bottleneck and have evidence that using a class instead actually solves the problem.

If you still do not know, after considering the above, then start by making it as a trait. You can always change it later, and in general using a trait keeps more options open.

正如“Mushtaq Ahmed”提到的那样,海峡不可能有任何参数传给某类主要建筑商。

另一个区别是处理<代码>super。

班级和海峡之间的另一区别是,在班级,super 电话是静态的,在海峡,电话是动态约束的。 如果您在某一班级书写<代码>super.toString,则你确切知道将采用哪种方法。 但是,如果你在海峡中写上同样的话,在你界定海峡时,援引超级呼吁的方法就没有界定。

详情见rel=“noreferer”第12章。

<>>Edit 1 (2013年):

与海峡相比,抽象班的表现方式存在微妙的差别。 一条线性化规则是,它保留了这些阶层的继承等级,这倾向于在链条后面推导抽象的班级,而海峡可能好坏参半。 在某些情况下,这实际上比后一种情况更可取,因此可以为此使用如此抽象的课堂。 见constraining pararization (mixin Order) in Scala。

<Edit 2 (2018):

截至2.12年,海峡双亲兼容性行为发生了变化。 在2.12之前,在海峡中增加或删除一个成员要求所有继承海峡的班次重新配对,即使这些班级没有改变。 这是因为证书在证书上编码了海峡。

截至Schala 2.12, traits , 因此,这一要求放宽了范围。 如果海峡有以下任何一种情况,其子类仍需要重新编造:

不管价值如何,Odersky等人的在Schala 的节目中建议,如果你怀疑,你使用海峡。 如果需要,你总是会将其改为抽象课程。

https://stackoverflow.com/questions/2005681/difference-between-abstract-class-and-trait>。 摘要班和Trait之间的差别:

trait A{
    def a = 1
}

trait X extends A{
    override def a = {
        println("X")
        super.a
    }
}  


trait Y extends A{
    override def a = {
        println("Y")
        super.a
    }
}

scala> val xy = new AnyRef with X with Y
xy: java.lang.Object with X with Y = $anon$1@6e9b6a
scala> xy.a
Y
X
res0: Int = 1

scala> val yx = new AnyRef with Y with X
yx: java.lang.Object with Y with X = $anon$1@188c838
scala> yx.a
X
Y
res1: Int = 1

在延长抽象的班级时,这显示该子类类似。 我认为,在使用海峡时,情况并非绝对。

Programing Scala 作者说,抽象的课堂形成了一种以古典标语为导向的“is-a”关系,而海峡则是组成的一个尺度。