scala java抽象理解_您将如何向六年级学生解释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，所以该示例不是最佳示例。

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

通用接口

假设我们有一个绘图程序需要处理许多不同形状的对象-Square，Circle，EquilateralTriangle等。在糟糕的过去，我们可能会用一堆if/else语句来完成此操作，例如：

def drawShapes(shapes: List[Shape]) =

for { shape

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

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

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

但希望您能看到我们的意图有所不同；即使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用于需要构造函数的东西。

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

我想知道如何(如果可能)创建一个类，它是泛型类的特定类型。具体来说，我有一个实现所有必需方法的abstract class Stack，我想有一个class StackInteger，而StackInteger的实例也是Stack的实例。我看到我可以做这样的事情：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…