我正在努力学习Scala--有过C++背景。我正在尝试为一个任务跟踪应用程序编写一个小类,这是我拼凑出来的,目的是帮助我学习如何编写Scala代码。
这看起来似乎应该很简单,但由于某种原因,它让我难以理解:
package com.catenacci.tts
class Task(val ID:Int, val Description:String) {
val EmptyID = 0
val EmptyDescription = "No Description"
def this() = this(EmptyID,EmptyDescription)
def thi
我试图在Scala反射中看到一个注解,但到目前为止还没有结果。我遗漏了什么?
我的注释:(Java)
@Target({ElementType.PARAMETER}) // Also tried ElementType.CONSTRUCTOR
@Retention(RetentionPolicy.RUNTIME)
public @interface MongoKey {
String info = "";
}
以及尝试使用Scala反射访问它的部分:
case class One(
@MongoKey name : String,
stuff : Lis
在scala类中,我定义了一个protected字段和一个protected方法:
TestProtected.scala:
class TestProtected {
protected var f = 0
protected def m = 1
}
在我看来,它将把受保护的f和m转换成一个受java保护的文件和方法。但是当我使用jd-gui将TestProtected.class反编译成java文件时,结果超出了我的预期:
@ScalaSignature(bytes="...")
public class TestProtected
{
private int
假设我有这样的Scala代码:
object Outer {
object Inner {
val B = "B"
}
class Inner {
def b = B
}
}
我希望这段代码可以编译,但是不能从b的定义访问B。我需要在class Inner中添加import Inner._才能使其工作。为什么会这样呢?伴生对象Inner是否没有正确定义?
我想使用静态方法Integer#bitCount(int)。但我发现我无法使用类型别名来实现它。类型别名和导入别名有什么区别?
scala> import java.lang.{Integer => JavaInteger}
import java.lang.{Integer=>JavaInteger}
scala> JavaInteger.bitCount(2)
res16: Int = 1
scala> type F = java.lang.Integer
defined type alias F
scala> F.bitCount(2)
<
考虑以下几类:
//A.java:
public interface A {
public static final String HIGHER = "higher";
}
//B.java:
public class B implements A {
public static final String LOWER = "lower";
}
在java代码中,我可以访问更高和更低的字段:
//JavaClient.java:
public class JavaClient {
public static void main(Strin
Scala类的“伴生对象”可以看作是一个单例对象,与类具有相同的完全限定名(即相同的名称,在相同的包中)。它们用来保存类的所有实例所共有的实用函数,作为Java的static方法的替代品。
然而,在文档和问题中的不同地方,它说伴生对象必须在同一个编译单元中定义。例如,必须在同一文件;中定义它们,因此出现以下警告消息:
warning: previously defined class Foo is not a companion to object Foo.
Companions must be defined together; you may wish to use :paste mode
我希望访问外部构造函数中的内部类类型,例如:
// does not compile, MyInner now know from outer constructor
class MyOuter(private val mySet: Set[MyInner]) {
class MyInner(index: Int)
}
内部类必须是非静态的(在对象之外),因为它可以访问外部类实例的某些字段。
下面的代码编译,但字段是可变的:
class MyOuter() {
class MyInner(index: Int)
private var mySet: Set[MyInner] =
因此,我知道在Scala中不能有静态成员,而是使用Singleton (虽然还没有完全理解这个概念)。因此,我假设Scala中的代码如下所示
import scala.collection.mutable.Map
//Making use of Singleton: companion Object & Class
class CheckSumAccumulator {
private var sum = 0
def add(b: Byte) { sum += b }
def checksum(): Int = ~(sum & 0xFF) + 1
}
objec
根据Scala (2.8),要找到隐式,必须在本地作用域、继承范围或伙伴对象中定义它。考虑到这一点,在我看来,下面的代码应该在不显式导入伴生对象的内容的情况下工作。我在Scala库源代码中看到了这一点(例如。CanBuildFrom)。我还应该能够从XX类的定义之外调用XX.foo(),并使用同伴类的隐式参数。我遗漏了什么?
object XX {
implicit def XYZ[T]: (T) => Unit = null
}
class XX {
// import XX._ // Works with this line uncommented...
de
我在scala项目中使用了几个案例类(Scala2.10)。我还使用了jacoco代码覆盖工具,版本为2.1.2。
当jacoco查看一个简单的案例类时,例如:
case class TestClass( val x : Int )
{
def double() : Int = x * 2
}
它报告了一个名为this()的自动生成对象的方法,它不接受任何参数。显然,我的课只接受一个参数。唯一能满足jacoco测试此方法的方法是进行这样的测试:
test( "Case class test" )
{
TestClass
}
我的主要问题是:
这个方法是为ca
我在Scala中有一个特征,一个伴生对象和一个类:
trait A {
protected var foo = "Foo"
}
object B extends A {
}
class B {
println(B.foo)
}
为什么我不能访问foo?我认为foo会成为对象"B“的一个字段。有没有办法做到这一点?
这是我的第一个scala文件,名为Node.scala
class Node extends NodeType
{
object Node {
val E = new Node(NodeType.E)
}
这是我的NodeType.scala
class NodeType extends Enumeration {
val PROGRAM = new NodeType()
val DECLARATIONS = new NodeType()
val DECLARATION = new NodeType()
val TYPE = new NodeType()
v
我试图实现一些模型行实现,类似于Scala中的Rails (Activerecord)。我只是想这么做;
trait Model[A]:
def query = "model has this good stuff I want to use in RowData"
trait RowData[B <: Model[B]]:
def query = B.query
case class Person(name: String, age: Int) extends RowData[Person]
object Person extends Model[Pers
我在Spark中实现了ml.Transformer的一个扩展;但是这个问题是Scala特有的。下面是一个示例对象(类/对象对的一部分):
abstract class UDFTransformer(func: UserDefinedFunction,
inputFieldNames: Seq[String],
outputFieldName: String) extends Transformer with MLWritable with Serializable {
... definitions her
我有许多值类,它们构成了一个更大的对象案例类。
final case class TopLevel(
foo: Foo,
bar: Bar
)
final case class Foo(foo: String) extends AnyVal
final case class Bar(bar: String) extends AnyVal
object Foo {
implicit val format = Json.valueFormat[Foo]
}
object Bar {
implicit val format = Json.valueFormat[Bar]
}
在学习Scala的过程中,我遇到了有趣的同伴对象的概念。伙伴对象可以用于在Scala中定义静态方法。在下面的Scala代码中,很少需要澄清有关伴生对象的内容。
class BballStatCounter extends Serializable {
val stats: StatCounter = new StatCounter()
var missing: Long = 0
def add(x: Double): BballStatCounter = {
if (x.isNaN) {
missing += 1
} else {
sta
在阅读Scala源代码时,我在scala/package.scala中遇到了以下情况,我不太明白为什么我们同时需要trait和val。trait关键字将化名为类,那么为什么我们需要val?
type StringBuilder = scala.collection.mutable.StringBuilder
val StringBuilder = scala.collection.mutable.StringBuilder
// Numeric types which were moved into scala.math.*
type BigDecimal = scala.