我正在尝试从O'Reilly的Programming Scala了解此代码示例。我是一名JavaScript程序员,而本书中的大多数解释都是以Java为背景的。我正在寻找对抽象类及其用途的简单,高级解释。
package shapes {
class Point(val x: Double, val y: Double) {
override def toString() = "Point(" + x + "," + y + ")"
}
abstract class Shape() {
def draw(): Unit
}
class Circle(val center: Point, val radius: Double) extends Shape {
def draw() = println("Circle.draw: " + this)
override def toString() = "Circle(" + center + "," + radius + ")"
}
}
参考方案
由于Shape
应该是trait
,而不是abstract class
,所以该示例不是最佳示例。
继承做两个独立但相关的事情:它让不同的值实现一个公共接口,并且让不同的类共享实现代码。
通用接口
假设我们有一个绘图程序需要处理许多不同形状的对象-Square
,Circle
,EquilateralTriangle
等。在糟糕的过去,我们可能会用一堆if/else
语句来完成此操作,例如:
def drawShapes(shapes: List[Shape]) =
for { shape <- shapes } {
if(isCircle(shape))
drawDot(shape.asInstanceOf[Circle].center)
...
else if(isSquare(shape))
drawStraghtLine(shape.asInstanceOf[Square].topLeft, shape.asInstanceOf[Square].topRight)
...
}
def calculateEmptySpace(shapes: List[Shape]) =
val shapeAreas = for { shape <- shapes } yield {
if(isCircle(shape)) (shape.asInstanceOf[Circle].radius ** 2) * Math.PI
else if(isSquare(shape)) ...
}
(在Scala中,我们实际上会使用模式匹配,但是暂时不用担心)
这是一种重复的模式。最好将重复的“找出正确的形状类型,然后调用正确的方法”逻辑隔离出来。我们可以自己编写这个想法(虚拟函数表):
case class ShapeFunctions[T](draw: T => Unit, area: T => Double)
object ShapeFunctions {
val circleFunctions = new ShapeFunctions[Circle]({c: Circle => ...}, {c: Circle => ...})
val squareFunctions = new ShapeFunctions[Square](...)
def forShape(shape: Any) = if(isCircle(shape)) circleFunctions
else if(isSquare(shape)) squareFunctions
else ...
}
def drawShapes(shapes: List[Shape]) =
for {shape <- shapes}
ShapeFunctions.forShape(shape).draw(shape)
但这实际上是一种普遍的想法,它已经内置在语言中。当我们写类似
trait Shape {
def draw(): Unit
def area(): Double
}
class Circle extends Shape {
val center: (Double, Double)
val radius: Double
def draw() = {...}
def area() = {...}
}
“在幕后”这样做是非常相似的;它正在创建包含此Circle.class
和draw()
方法的特殊值area()
。当您通过Circle
创建val circle = new Circle()
以及普通字段center
和radius
的实例时,此Circle
具有一个神奇的隐藏字段circle.__type = Circle.class
。
调用shape.draw()
时,这等效于shape.__type.draw(shape)
(不是真正的语法)。很好,因为这意味着如果shape
是Square
,则调用将是Square.class.draw(shape)
(同样,不是真正的语法),但是如果是Circle
,则调用将是Circle.class.draw(shape)
。请注意,如何始终使用正确类型的值来调用类(无法调用Square.class.draw(circle)
,因为circle.draw()
始终使用正确的实现)。
现在,许多语言在没有trait
部分的情况下有点类似。例如,在Python中,我可以执行以下操作:
class Square:
def draw(self): ...
class Circle:
def draw(self): ...
当我呼叫shape.draw()
时,它将呼叫正确的事物。但是如果我还有其他课程:
class Thursday: ...
那么我可以调用new Thursday().draw()
,并且在运行时会收到错误消息。 Scala是一种类型安全的语言(或多或少):此方法可以正常工作:
def doSomething(s: Square): s.draw()
虽然此方法无法编译:
def doSomething(t: Thursday): t.draw()
Scala的类型系统非常强大,您可以使用它来证明有关代码的各种事情,但是至少,它保证的一件好事是“您永远不会调用不存在的方法”。但是,当我们想在未知类型的形状上调用draw()
方法时,这会带来一些问题。在某些语言中(例如,我相信Ceylon),您实际上可以编写这样的方法(无效的Scala语法):
def drawAll(shapes: List[Circle or Square or EquilateralTriangle]) = ...
但这并不是我们真正想要的:如果有人编写了自己的Star
类,只要它具有drawAll
方法,我们希望能够将其包含在传递给draw()
的列表中。
这就是trait
出现的地方。
trait Shape {
def draw(): Unit
def area(): Double
}
class Circle extends Shape {...}
大致意味着“我保证Circle
具有def draw(): Unit
方法。(请记住,这实际上意味着”我保证Circle.class
包含值draw: Circle => Unit
)。编译器将执行您的诺言,如果未实现给定方法,则拒绝编译Circle
。然后我们可以做:
def drawAll(shapes: List[Shape]) = ...
并且编译器要求shape
中的每个shapes
都来自具有def draw(): Unit
方法的类型。因此shape.__type.draw(shape)
是“安全的”,并且我们的方法可以保证仅调用实际存在的方法。
(实际上,Scala还具有更强大的方式来实现相同的效果,即typeclass模式,但现在就不用担心了。)
共享实施
这比较简单,但也很“麻烦”-这是纯粹的实际操作。
假设我们有一些与对象状态相关的通用代码。例如,我们可能有一堆可以吃东西的不同动物:
class Horse {
private var stomachContent: Double = ...
def eat(food: Food) = {
//calorie calculation
stomachContent += calories
}
}
class Dog {
def eat(food: Food) = ...
}
不必将相同的代码编写两次,我们可以将其放在trait
中:
trait HasStomach {
var stomachContent: Double
def eat(food: Food) = ...
}
class Horse extends HasStomach
class Dog extends HasStomach
请注意,这与我们在前一种情况下编写的内容相同,因此我们也可以以相同的方式使用它:
def feed(allAnimals: List[HasStomach]) = for {animal <- allAnimals} ...
但希望您能看到我们的意图有所不同;即使eat
是任何外部函数都无法调用的“内部”方法,我们也可能会做同样的事情。
有人批评“传统的” OO继承,因为它“混合”了这两种含义。没有办法说“我只想共享这段代码,不想让其他函数调用它”。这些人倾向于争辩说共享代码应该通过组合来实现:与其说我们的Horse
扩展了HasStomach
,不如说是在我们的Stomach
中编写了一个Horse
:
class Stomach {
val content: Double = ...
def eat(food: Food) = ...
}
class Horse {
val stomach: Stomach
def eat(food: Food) = stomach.eat(food)
}
这种观点有些道理,但根据我的经验,在实践中,它倾向于比“传统的OO”方法花费更长的代码,尤其是当您想为带有一些小,两种类型之间的细微差别。
抽象类与特质
到目前为止,我所说的所有内容都同样适用于trait
和abstract class
es(在一定程度上也适用于class
es,但我们不要赘述)。
在许多情况下,trait
和abstract class
都可以使用,有人建议使用差异来声明意图:如果要实现公共接口,请使用trait
,并且要共享实现。代码,请使用abstract class
。但是我认为最重要的区别在于构造函数和多重继承。
Scala允许多重继承;一堂课可能extend
几个父母:
class Horse extends HasStomach, HasLegs, ...
出于显而易见的原因,这很有用,但在菱形继承情况下可能会出现问题,尤其是当您具有调用超类方法的方法时。有关Python中出现的一些问题,请参见Python's Super Considered Harmful,并注意在实践中,大多数问题都发生在构造函数上,因为这些通常是要调用超类方法的方法。
Scala为此提供了一个优雅的解决方案:abstract class
可能有构造函数,但trait
可能没有构造函数。一个类可以从任何数量的trait
继承,但是abstract class
必须是第一个父级。这意味着任何类都只有一个父对象具有一个构造函数,因此,很明显哪个方法是“超类构造函数”。
因此,在实际代码中,我的建议是在可能的情况下始终使用trait
,并且仅将abstract class
用于需要构造函数的东西。
我想知道如何(如果可能)创建一个类,它是泛型类的特定类型。具体来说,我有一个实现所有必需方法的abstract class Stack<Type>,我想有一个class StackInteger,而StackInteger的实例也是Stack<Integer>的实例。我看到我可以做这样的事情:class StackInteger { …
Java-关于使用具有静态成员的类vs. - java所以我有一个关于最佳实践的问题。基本上,我正在执行以下操作以简化访问不同类的成员的操作:class myClass1 { public static int var1; public static String var2; //... public static void method1() { //... } } 然后在其他类中,我只能使用myClass1…
Java:线程池如何将线程映射到可运行对象 - java试图绕过Java并发问题,并且很难理解线程池,线程以及它们正在执行的可运行“任务”之间的关系。如果我创建一个有10个线程的线程池,那么我是否必须将相同的任务传递给池中的每个线程,或者池化的线程实际上只是与任务无关的“工人无人机”可用于执行任何任务?无论哪种方式,Executor / ExecutorService如何将正确的任务分配给正确的线程? 参考方案 …
JAVA:字节码和二进制有什么区别? - javajava字节代码(已编译的语言,也称为目标代码)与机器代码(当前计算机的本机代码)之间有什么区别?我读过一些书,他们将字节码称为二进制指令,但我不知道为什么。 参考方案 字节码是独立于平台的,在Windows中运行的编译器编译的字节码仍将在linux / unix / mac中运行。机器代码是特定于平台的,如果在Windows x86中编译,则它将仅在Win…
java:继承 - java有哪些替代继承的方法? java大神给出的解决方案 有效的Java:偏重于继承而不是继承。 (这实际上也来自“四人帮”)。他提出的理由是,如果扩展类未明确设计为继承,则继承会引起很多不正常的副作用。例如,对super.someMethod()的任何调用都可以引导您通过未知代码的意外路径。取而代之的是,持有对本来应该扩展的类的引用,然后委托给它。这是与Eric…