您将如何向六年级学生解释Scala的抽象类功能? - java

我正在尝试从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,所以该示例不是最佳示例。

继承做两个独立但相关的事情:它让不同的值实现一个公共接口,并且让不同的类共享实现代码。

通用接口

假设我们有一个绘图程序需要处理许多不同形状的对象-SquareCircleEquilateralTriangle等。在糟糕的过去,我们可能会用一堆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.classdraw()方法的特殊值area()。当您通过Circle创建val circle = new Circle()以及普通字段centerradius的实例时,此Circle具有一个神奇的隐藏字段circle.__type = Circle.class

调用shape.draw()时,这等效于shape.__type.draw(shape)(不是真正的语法)。很好,因为这意味着如果shapeSquare,则调用将是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”方法花费更长的代码,尤其是当您想为带有一些小,两种类型之间的细微差别。

抽象类与特质

到目前为止,我所说的所有内容都同样适用于traitabstract class es(在一定程度上也适用于class es,但我们不要赘述)。

在许多情况下,traitabstract 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用于需要构造函数的东西。

Java-非泛型类扩展了泛型类 - java

我想知道如何(如果可能)创建一个类,它是泛型类的特定类型。具体来说,我有一个实现所有必需方法的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:字节码和二进制有什么区别? - java

java字节代码(已编译的语言,也称为目标代码)与机器代码(当前计算机的本机代码)之间有什么区别?我读过一些书,他们将字节码称为二进制指令,但我不知道为什么。 参考方案 字节码是独立于平台的,在Windows中运行的编译器编译的字节码仍将在linux / unix / mac中运行。机器代码是特定于平台的,如果在Windows x86中编译,则它将仅在Win…

java:继承 - java

有哪些替代继承的方法? java大神给出的解决方案 有效的Java:偏重于继承而不是继承。 (这实际上也来自“四人帮”)。他提出的理由是,如果扩展类未明确设计为继承,则继承会引起很多不正常的副作用。例如,对super.someMethod()的任何调用都可以引导您通过未知代码的意外路径。取而代之的是,持有对本来应该扩展的类的引用,然后委托给它。这是与Eric…