访问案例类的静态成员

Question

我有一些代码

case class A(s:String) {val x = "hello"}

为什么在不实例化 A 类的情况下无法访问静态变量 x ？如果我输入，

A.x

则会出现以下错误：

error: value x is not a member of object A

编辑：

我错过了提及剩余的代码。这是我想使用的示例：

abstract class A { val name:String }
case class B(i:Int) extends A { val name = "B" }
case class C(b:Boolean) extends A { val name = "C" }
def getType(s:String) = s match {
  case B.name => println ("Object B")
  case C.name => println ("Object C")
}

错误：

  scala> def getType(s:String) = s match {
 |       case B.name => println ("Object B")
 |       case C.name => println ("Object C")
 |     }
 <console>:11: error: value name is not a member of object B
         case B.name => println ("Object B")
                ^
 <console>:12: error: value name is not a member of object C
         case C.name => println ("Object C")
                ^

至于为什么用例类，没有为此目的定义用例类。在其他地方我有一些代码，例如：

def func(a:A) = a match {
  case b:B =>
  case c:C =>
  ...
}

Answer 1

好吧，你不能调用“静态”变量 x，因为在 Scala 中没有静态变量。您声明 x 是 A 类的常规成员，如果您有 A 类的实例，则可以访问它。

您尝试通过调用 Ax 来访问名为“A”的值。范围内恰好有这样一个值 - 编译器为您的案例类 A 生成了伴生对象。

但是该对象 A 没有成员“x”，因此编译器正确地抱怨它。

您可以通过执行以下操作将值 x 添加到对象 A 而不是类/类型 A：

case class A(s:String)
object A { val x = "hello" }

Answer 2

从您描述的问题的少量来看，案例类似乎不适合您。
替代模式包括...

常量：

val Abs1 = "1" //note that it starts with an uppercase letter
val s: String = ...
s match {
  case Abs1 => ...
  case _ =>
}

提取器：

object Positive {
  def unapply(i: Int): Option[Int] = if(i >= 0) Some(i) else None
}

val i: Int = ...
i match {
  case Positive(p) => ... //p will be bound to the matched positive number
  case _ => ...
}

Case 类（正确使用）：

case class MyType(s: String)
val x: MyType = ...

x match {
  case MyType("a") => ...
  case MyType("b") => ...
  case MyType(matched) => ...
    //matched will be bound to whatever string was used to construct the MyType instance
}

Case 对象：

abstract sealed trait Foo { def s: String }
case object Bar extends Foo { val s = "I'm a Bar" }
case object Baz extends Foo { val s = "I'm a Baz" }

val x: Foo = ...
x match {
  case Bar => ...
  case Baz => ...
  //no other possibilities because Foo is sealed
}

Answer 3

暂时把设计问题放在一边。

如果您需要解决方法，则可以将标识符绑定到匹配的案例类或案例对象，并使用绑定的标识符来访问匹配实体的成员。绑定标识符可以在匹配中的保护语句中或在为匹配提供的操作中使用：

case class Bob(x: String, y: String) {val z = "Bragging"}

val bob1 = Bob("Big", "Bad")

bob1 match {
  case b @ Bob(x, y) if b.z == "Bragging" => println("Got "+x+", "+y+", "+b.z+" Bob!")
  case _ =>
}

case object Bob {val z = "Balding"}

val bob2 = Bob

bob2 match {
  case b @ Bob if b.z == "Balding" => println("Got "+b.z+" Bob!")
  case _ =>
}

返回到设计，在您的案例类定义中，您在 B 的构造函数主体中声明“名称”，但您可以通过使用“ name' 作为参数：

case class B(i: Int, name: String) extends A

然后可以像这样匹配：

def getType(s:String) = s match {
  case B(_, name) => println ("Object B("+name+")")
  ...

最后，如果没有进一步的细节，很难说，但我怀疑将案例类一对一地映射到一大组相似的实体可能不是最好的选择，最好用例对象，或者有限数量的用例类甚至元组的实例。