标签: companion-object

在一个伴侣对象中,我希望有一个字段记录从伴侣类中实例化的所有实例(它是抽象的),我可以这样做吗？

特别是,我认为this会引用子类的任何实例,但是当我在伴随对象中使用它时它将不会编译.

我有一个特性,初始化本身并不是线程安全的,但是它主要用作伴随对象的基础,根据定义,初始化是线程安全的.

是否有某种方法可以保证(在编译或运行时)特征总是由伴随对象扩展？该特征具有一种方法,该方法始终仅在伴随对象初始化期间被调用,该方法可以是验证的站点.

通常,我首先在同一个文件中写一个case class然后是同伴object,就在下面.但是当试图导入implicit同伴中的声明时,我被迫切换声明的顺序(显然我不想要).克服这种情况的建议做法是什么？

对于具体情况,以下代码不起作用:

  object SomeLib {
     def doSomething[T : List](t: T) = "meh"
  }

  case class FooWorker(x: String) {
    import FooWorker._ // bring the implicit in scope for doSomething
    def then(event: String) : FooWorker = {
      copy(x = SomeLib.doSomething(event)) // requires implicit
    }
  }

  object FooWorker {
    implicit val list = List("a", "b", "c")
  }

但如果我object FooWorker在case class FooWorker它确实工作之前宣布.我正在使用Scala 2.11.6和SBT进行测试.非常感谢!

我正在使用IntelliJ的Scala插件的最新版本并拥有以下代码片段,其目的是允许枚举类的实例Count:

class Count() {
  val id = Count.id()
  override def toString = s"Count$id"
}

object Count {
  var n = -1
  def id() = { n += 1; n }
}

println(Vector(new Count, new Count, new Count))

当引用id()伴随对象的方法时,IntelliJ给我一个前向引用错误,但脚本编译完美,产生输出Vector(Count0, Count1, Count2).实际上,在成功运行脚本之后,我只是偶然发现了错误.是什么赋予了？

我想将构造函数及其字段隐藏在一个类中，并且只使用伴随对象创建实例，但我无法实现。我有 Scala 2.13.3，它基于 java 8。这是一个代码示例：

斯卡拉

package X

object A {
  def apply(x: Int): A = A(Seq(x))
}

case class A private(private val s: Seq[Int])

甜菜

package Y

import X.A

class B {
  val b = A(Seq.empty)
}

虽然我只想让apply(x:Int)这段代码可见，但编译后的私有构造函数也是可见的。如何更改此代码以按预期工作？

我花了这么多时间在我的伴侣对象中组合一个工厂方法,如下所示:

class Stuff(val a: Int, val b: Long) { this() = this(0,0L) }

object Stuff {
  def apply(a:Int, b:Int) = new Stuff(a, b.toLong)
}

但是,当我以为我杀了它时,我就去编译,这不起作用:

val widget = new Stuff(1,2)

到底是怎么回事!？我刚做完了!？救命!!!

尝试使用案例类实现智能构造函数。设法copy很好地覆盖了该方法，并且我认为apply伴随对象中的 应该可以解决问题，但是在尝试传入BigInt. 我尝试放入def apply(value: BigInt): Option[Natural]但随后scalac抱怨符号冲突。

import spire.math.Integral // companion object contains implicit Integral[BigInt]

case class Natural private (value: BigInt) {
  def copy(value: BigInt = this.value): Option[Natural] =
    Natural.apply(value)
}

object Natural {
  def apply[A](x: A)(implicit A: Integral[A]): Option[Natural] =
    if (A.isPositive(x)) Some(Natural(x))
    else None
}

/** In Foo.scala */
Natural(5L) // Option[Natural] = Some(Natural(5))
Natural(BigInt(5L)) // constructor Natural in class Natural cannot be accessed in object Foo

也许这样的事情是不可能的？

请参阅下面的源代码.所有源代码都在同一个包中定义.当我定义一个源文件中的所有代码ShowMain.scala,我得到一个编译错误,但是当object ShowMain在被定义ShowMain.scala并trait Show与object Show中定义Show.scala,也没有编译错误.

我的问题: 这是什么原因？我遇到了什么语言规则？

示例代码:

object ShowMain {

  def main(args: Array[String]): Unit = {
    output("hello")
  }

  def output[A](a: A)(implicit show: Show[A]) =
    println(show.show(a))

}

trait Show[-A] {
  def show(a: A): String
}

object Show {

  implicit object StringShow extends Show[String] {
    def show(s: String) = s"[String: $s]"
  }

}

编译错误:

(ScalaIDE/Scala 2.11.2在线包含output("hello"))

Multiple markers at this line
    - not enough arguments for method output: …

我正在尝试通过消息（在 Akka 游戏环境中）构造 atrait和abstract classto 子类型，以便我可以轻松地将它们转换为Json.

到目前为止做了什么：

    abstract class OutputMessage(val companion: OutputMessageCompanion[OutputMessage]) {
        def toJson: JsValue =  Json.toJson(this)(companion.fmt)
    }


    trait OutputMessageCompanion[OT] {
        implicit val fmt: OFormat[OT]
    }

问题是，当我尝试按如下方式实现上述接口时：

    case class NotifyTableChange(tableStatus: BizTable) extends OutputMessage(NotifyTableChange)

    object NotifyTableChange extends OutputMessageCompanion[NotifyTableChange] {
        override implicit val fmt: OFormat[NotifyTableChange] = Json.format[NotifyTableChange]
    }

我从 Intellij 收到此错误： Type mismatch, expected: OutputMessageCompanion[OutputMessage], actual: NotifyTableChange.type

我对 Scala 泛型有点陌生 - 所以对一些解释的帮助将不胜感激。

PS我愿意接受比提到的更通用的解决方案。目标是，在获取任何子类型OutputMessage- 时，轻松将其转换为Json.

我想做如下的事情：

inline fun<T: Enum<T>> myFunction(enumStr: String){
    T.valueOf(enumStr)
    //...
}

这样我的泛型参数就被限制为枚举类类型，以便我可以访问 valueOf 函数。我收到一条错误消息，指出：
Type parameter 'T' cannot have or inherit a companion object, so it cannot be on the left hand side of dot

我理解这意味着我不能在泛型上使用伴随对象函数。有什么方法可以实现我想要的 - 将字符串转换为通用枚举？