爲什麼需要類型同義詞來定義在Scala中匹配Java類的patten抽取器？

Question

如果有現有的Java類pkg.Test，

package pkg; 
public class Test { 
    public int v; 
    public Test(int v) { this.v = v; } 
} 

試圖通過定義斯卡拉同伴對象

package pkg 
object Test{ 
    def unapply(t : Test) : Option[Int] = Some(t.v) 
} 

產生的錯誤，使提取器「測試已經被定義爲對象測試」。 然而，一切似乎如果我做了Java類的同義詞在一個新的包

package pkg 
package object matchers { 
    type Test = pkg.Test 
} 

工作，在新的包

package pkg.matchers 
object Test { 
    def unapply(t : Test) : Option[Int] = Some(t.v) 
} 

現在定義相應的對象的模式，所有成員都的原始類可從新包中提取

import pkg.matchers._ 
object main { 
    def main(args : Array[String]) { 
    val t = new Test(1) 
    t match {case Test(v) => println(v)} 
    println(t.v) 
    } 
} 

添加類型同義詞讓這項工作看起來很奇怪。除了必須使用新的軟件包之外，這種方式添加模式匹配還有什麼問題嗎？有什麼方法可以使原始包裝中的提取器可用？

Answer 1

這是因爲當與Java庫交互時，Scala需要一種將Java的靜態方法映射到Scala的單例對象的方法。

例如，如果您有以下Java類：

package pkg; 

class Test { 
    public static void printHello() { 
    System.out.println("Hello"); 
    } 
} 

，我們怎樣才能斯卡拉調用printHello？它將如下所示：

import pkg.Test 
Test.printHello() 

正如你所看到的，語法是在object Test調用的方法完全相同。從這一點來看，已經定義了Test單身人士，並且您不能用相同的FQN兩次定義object。

這就是爲什麼你需要定義pkg.matchers.Test所以它不會與pkg.Test衝突。

和Scala的編譯器足夠聰明弄清楚，pkg.matchers.Test是使用new關鍵字可能無法構造它一個單身，所以，當你寫new Test(1)，它是pkg.Test，而不是pkg.matchers.Test。這就是爲什麼你可以在你的代碼示例中同時使用它們。

其實，你並不需要type Test = pkg.Test可言，下面是工作的罰款：

package pkg 

package matchers { 
    object Test { 
    def unapply(t : Test) : Option[Int] = Some(t.v) 
    } 
} 

object main { 

    import pkg.matchers._ 

    def main(args : Array[String]) { 

    val t = new Test(1) 
    t match {case Test(v) => println(v)} 
    println(t.v) 
    } 
} 

更新

提取不需要爲伴侶對象，這意味着你不t需要相應的類。任何object與unapply方法可以作爲提取器。

object StringLength { 
    def unapply(x: String): Option[Int] = Some(x.length) 
} 

object Main { 

    def main(args: Array[String]) { 

    "Hello World" match { 
     case StringLength(x) => println("length:" + x) 
    } 
    } 
} 

因此，如果主要方法是不是在pkg，您有以下選擇：

1. 重命名提取到另一個名字，因此編譯器可以知道你正在使用提取。

2. 使用FQN，因此編譯器知道您訪問pkg.matchers.Test而不是pkg.Test。

   package pkg.matchers { 
   
       import pkg._ 
   
       object Test { 
       def unapply(t : Test) : Option[Int] = Some(t.v) 
       } 
   } 
   
   object Main { 
   
       def main(args: Array[String]) { 
   
       import pkg.Test 
   
       val t = new Test(1) 
       t match {case pkg.matchers.Test(v) => println(v)} 
       println(t.v) 
   
       } 
   
   } 
   

3. 重命名pkg.Test另一名與import語法，所以它不會與pkg.matchers.Test衝突。

   object Main { 
   
       def main(args: Array[String]) { 
   
       import pkg.{Test => JTest} 
       import pkg.matchers.Test 
   
       val t = new JTest(1) 
       t match {case Test(v) => println(v)} 
       println(t.v) 
   
       } 
   } 
   

4. 剛剛從pkg進口的一切，擁有自營pkg.matcher.Test明確。

   def main(args: Array[String]) { 
   
       import pkg._ 
       import pkg.matchers.Test 
   
       val t = new Test(1) 
       t match {case Test(v) => println(v)} 
       println(t.v) 
   
       }