विभिन्न एक्स के लिए पैटर्न-एक्स कक्षा [एक्स] कैसे करें?

Question

मैं किसी विधि के पैरामीटर के प्रकार की जांच करना चाहता हूं, लेकिन मुझे ऐसा करने का सबसे अच्छा तरीका नहीं पता है। मेरा कोड देखें:

class X { 
    def x(a: Int, b: String) {} 
} 

val methods = classOf[X].getDeclaredMethods 
methods map { m => 
    m.getParameterTypes.toList map { t => 
     println(t.getName) 
     // I don't know how to write the following 
     if (the type of t is Int) { do something} 
     else if(the type of t is String) { do something} 
     else { } 
    } 
} 

कृपया कोड में टिप्पणी को नोट करें। मुझे नहीं पता कि स्केल तरीके में प्रकारों को कैसे जांचें।

मैं कोशिश की है:

t match { 
    case _:String => println("### is a string") 
    case _:Int => println("### is an int") 
    case _ => println("### ?") 
} 

लेकिन यह संकलित नहीं किया जा सकता।

if (t.isAssignableFrom(classOf[String])) // do something 
else if(t.isAssignableFrom(classOf[Int])) // do something 
else {} 

ऐसा लगता है हम स्केला में इसका इस्तेमाल करना चाहिए, सही:

मैं जावा तरह से जाँच करने के लिए उपयोग कर सकते हैं?

---

अद्यतन:

मैं match उपयोग करना चाहते हैं, मैं इस तरह लिखना चाहिए:

t match { 
    case i if i.isAssignableFrom(classOf[Int]) => println("### is an Int") 
    case s if s.isAssignableFrom(classOf[String]) => println("### is a String") 
    case _ => println("###?") 
} 

यह सबसे अच्छा जवाब है?

Answer 1

मैं इसे स्थिरांक के रूप में मामलों को परिभाषित करके एक प्रकार के रूप में टी के साथ काम कर सकता हूं। यह वर्ग अभिव्यक्तियों के साथ केस अभिव्यक्ति के रूप में संकलित नहीं होगा। प्रयास करें:

val S = classOf[String] 
val I = classOf[Int] 
t match { 
    case S => println("### is a string") 
    case I => println("### is an int") 
    case _ => println("### ?") 
} 

Answer 2

आप ClassManifest.fromClass का उपयोग सही ढंग से AnyVals को पुरातन का बलात्कार, और किसी अन्य ऐसे मुसीबतों का सामना आप अनबॉक्स्ड प्रकार बनाम बॉक्सिंग हो सकता है जब प्रतिबिंब के साथ फंकी हो रही संभाल कर सकते हैं।

इस तरह

:

import reflect.ClassManifest 

class Wibble { def method(a:Int, b: String) =() } 

for(method <- classOf[Wibble].getDeclaredMethods; paramType <- method.getParameterTypes) { 
    ClassManifest.fromClass(paramType) match { 
    case m if m <:< ClassManifest.Int => println("Interiffic") 
    case m if m <:< ClassManifest.Float => println("Floaty, like butterflies") 
    case m if m <:< ClassManifest.Double => println("Or Quits...") 
    //todo: all the other AnyVal types... 
    case m if m <:< classManifest[String] => println("bleeding edge physics, yeah baby!") 
    //...and a default condition 
    } 
}