标签: companion-object

我定义了以下代码(在Scala IDE/Scala工作表中使用Scala 2.10):

object WorkSheet1 {
  object A {
    def apply(s: String, huh: Boolean = false): A = A(s)
  }
  case class A (s: String)
  //case class A private (s: String)
  val a = A("Oh, Hai")
}

我成功收到以下输出:

a:public_domain.WorkSheet1.A = A(哦,海)

但是,当我注释掉现有的case class A (s: String)并取消注释掉另一个(包含" private ")时,我收到以下编译器错误:"在对象WorkSheet1中无法访问类A中的构造函数A".

我的理解是,一个伴侣对象可以访问它所有的伴侣类的私有部分.嘿.呃......说真的.是什么赋予了？

我可以在不参考类的实际对象的情况下检查伴随对象中的字段值吗？

我想存储一个静态计数器,每次创建该类的新对象时都增加它,并且能够在不使用对象本身的情况下检查它的值,这可能吗？

我无法使用伴随对象创建表示XML解析文档的类.

这是该类的代码:

package models

import javax.xml.bind.Element
import scala.xml.Elem
import javax.xml.validation.SchemaFactory
import javax.xml.transform.stream.StreamSource


trait MyXML {

case class ElémentXML(code_xml: scala.xml.Elem) {

def validate: Boolean = {

try ({
  val schemaLang = "http://www.w3.org/2001/XMLSchema"
  val factory = SchemaFactory.newInstance(schemaLang)
  val schema = factory.newSchema(new StreamSource("Sites_types_libelles.xsd"))
  val validator = schema.newValidator()
  validator.validate(new StreamSource(code_xml.toString))
  true
}) catch {
  case t:Throwable => false
}
}



}

object ElémentXML {

def apply(fichier: String) {

  try{
  val xml_chargé = xml.XML.loadFile(fichier)
  Some(new ElémentXML(xml_chargé))
  }catch{
    case e:Throwable => None
  }
}
}

} …

object Test extends App {

  def print(s: String)(implicit p: Prefixer) = {
    println(p.prefix + s)
  }

  print("test")

}

case class Prefixer(prefix: String)

object Prefixer {
  implicit val p = Prefixer("***")
}

上面的代码无法编译,因为编译器无法为Prefixer找到隐式值.但是,如果我将case类Prefixer和伴随对象放在另一个文件中,它就可以工作.这是为什么？

我是scala的新手并试图理解scala oops概念.我创建了一个类:

class MyComp private{
    // some fields and method goes here
    }

当我编译它时

scalac MyComp.scala

它创建了一个私有构造函数.但是当我创建一个伴侣对象而不是构造函数变得公开时,我无法理解这个概念.请清楚

这是MyComp类的伴随对象的代码

object MyComp
{
    private val comp= new MyComp;
    def getInstance= comp;
}

我在scala中创建伴随对象并尝试object在class不导入的情况下使用implictis函数.但无论何时,尝试编译代码我都会收到错误:type mismatch;似乎无法自动导入implictis.以下是我的代码:

object ImplicitTest5 {
    implicit def dollarToRupa(dollar: Dollar): Rupa = { 
        println("calling .... dollarToEuro") 
        Rupa(dollar.value)
    } 

    implicit def dollarToEuro(dollar: Dollar): Euro = { 
        println("calling .... dollarToEuro") 
        Euro(dollar.value)
    } 
}

case class Dollar(value: Double)

case class Euro(value: Double)

case class Rupa(value: Double)

class ImplicitTest5 { 

    private val value = "String"

    def conversion = {
        val euro: Euro  = Dollar(3.1)
        println(s" ----- $euro")
    }
}

当我import ImplicitTest5._在我的班级使用时,它将编译并运行正常.根据Scala中的Programming,Page:478它将正常工作,并且不需要定义导入. …

我想.MAX在通用枚举上表示值计数.

我试着玩一点,但我想不出来.

当我写作时,例如,这个:

val Enum.Companion.MAX get() = enumValues().size

它抱怨enumValues()说

类型推断失败:没有足够的信息来推断参数T in

inline fun> enumValues():Array请明确指定它.

这很有道理,然后我也试过了:

val <E> Enum<E>.Companion.MAX get() = enumValues().size

它抱怨第二个 E

引用嵌套类时,外部类的类型参数是多余的

有办法吗？

// Script A.scala
class A {
    private val privateVal = 1
}
object A extends App{ 
    println(new A().privateVal)
}

A.scala可以编译和运行，因为伴侣对象及其类可以访问彼此的私有成员，因此不会出现问题。

$ scalac A.scala
$ scala A
1

为什么在解释时相同的代码会显示伴随对象无法访问其伴随类中的私有val？

$ scala A.scala
error: value privateVal in class A cannot be accessed in A

下面是一个测试 scala 2.13 编译器隐式特性的简单示例：

object OverridingScope {

  trait System {

    trait Handler[T]
  }

  object Sys1 extends System {

    object Handler {

      implicit def handle1: Handler[Int] = new Handler[Int] {}
    }

    implicit def handle2: Handler[Long] = new Handler[Long] {}
  }
}

根据这篇文章：

Scala 在哪里寻找隐式？

Handler当使用 type 时，trait 的伴生对象可以作为隐式作用域的一部分自动导入Handler[_]，外部对象Sys1应该是无关紧要的。这意味着 handle1 应该是可见的，而 handle2 应该是隐藏的。

但是下面的测试用例显示了完全相反的情况：

class OverridingScope extends BaseSpec {

  import OverridingScope._

  it("implicits in companion is in scope") {

//    val hh = implicitly[Sys1.Handler[Int]]
    // Doesn't work
  } …

众所周知，Kotlin 和 Java 是可以互操作的。当我尝试访问 Kotlin 代码中的 Java 静态变量时，它可以工作，但是当我尝试访问 Java 中的伴生对象时，它不起作用。