scala> def foo[U](t: Any) = t.asInstanceOf[U]
foo: [U](t: Any)U
scala> val s: String = foo("hi")
scala> val n = foo("hi")
java.lang.ClassCastException: java.lang.String cannot be cast to scala.runtime.Nothing$
at .<init>(<console>:6)
at .<clinit>(
给定以下测试用例,其中有3种方案。我会问这里的规则是什么,什么时候我们必须,什么时候我们不需要指定类型参数
@Test
def testTypeParamter(): Unit = {
class Cat[A]
//1. Don't need to specify the type parameter for Cat
def getCat() = new Cat
println(getCat())
import scala.collection.mutable.ArrayBuffer
//2. Don't need
我有这样的代码:
sealed trait Foo[A] {
def value: A
}
case class StringFoo(value: String) extends Foo[String]
case class IntFoo(value: Int) extends Foo[Int]
我希望有一个函数,它可以使用给定子类型的类型参数的A类型。
// Hypothetical invocation
val i: Int = dostuff[IntFoo](param)
val s: String = dostuff[StringFoo](param)
我不知道如何以一种有效的方式
我试图在实例中获取反射运行时方法,但它没有显示在decls结果中:
val foo: AnyRef = new Object {
def bar = 1
}
typeOf[foo.type].decls //Does not contain bar method
我尝试使用Java反射类,它可以工作:
foo.getClass.getDeclaredMethods //It contains bar method
但是我更喜欢使用MethodSymbols和Scala,而不是Java和方法反射。如何获得反射的MethodSymbol?
我想要一个方法来查找作为AnyRef传递给方法栏的对
TL;DR
我认为我的TL;DR是如何我的部分泛型函数?但是,我增加了一些细节来尝试和帮助。我尝试过谷歌搜索,但我对Scala相当陌生,所以我想有一两个术语我错过了。
背景
我正在尝试减少一些样板,我遇到了一种情况,我似乎无法理解Scala语法。我有一个包装未来的包装,看起来像:
// Wrapper for a block that sends timing data to statsd using a Stats class
object Timed {
def apply[A](key: String, maybeStat: Option[Stats] = None)(block:
我已经知道:
<:是Scala语法类型约束。
虽然<:<是利用Scala隐式达到类型约束的类型
例如:
object Test {
// the function foo and bar can have the same effect
def foo[A](i:A)(implicit ev : A <:< java.io.Serializable) = i
foo(1) // compile error
foo("hi")
def bar[A <: java.io.Serializable](i:A)
我在java和scala中都有非常简单的示例:
public class LowerBound {
public void myFunction(List<? super Integer> myList) {
myList.forEach(System.out::println);
}
}
public class LowerBoundMain {
public static void main(String[] args) {
LowerBound lb = new LowerBound();
List
public abstract class Flattenable<T_Id, T_Order> where T_Id : struct, IComparable
where T_Order : IComparable
{
public abstract T_Id ID { get; }
public abstract Nullable<T_Id> Parent_ID { get; }
public abstract T_Order Order {
给定Java类
public class Test {
public static int foo(Object o) {
return 10;
}
}
Scala编译器将参数类型Object映射到scala.Any。
scala> Test.foo _
res0: Any => Int = <function1>
我想原因是允许将Scala原语(如true)传递给这样的函数,这在许多情况下可能是可取的。有什么重要的例子吗?
scala> Test.foo(true)
res1: Int = 10
下面是一个反例:
scala> val h
在2.8.1/2.9.0.1REPL中尝试以下命令,第一个命令会给出一个错误。
val l = List(Vector(1,2), List(3,4,5))
error: type mismatch;
found : scala.collection.immutable.Vector[Int]
required: scala.collection.immutable.Seq[Int]{def companion: scala.collection.generic.GenericCompanion[scala.collection.immutable.Seq[Any]]; pro
假设我有一个泛型类:
class SomeClass<Element> {
// What is the difference between this:
var array: [SomeClass]!
// and this declaration:
var array2: [SomeClass<Element>]!
}
这些声明之间有什么区别?
有人能解释一下为什么下面的代码不起作用吗?
scala> abstract class A[T] {}
defined class A
scala> class B {}
defined class B
scala> object C extends A[B] {}
defined object C
scala> def method(arg: A[Any]): Unit = {}
method: (arg: A[Any])Unit
scala> method(C)
<console>:14: error: type mismatch;
fo
假设我有以下泛型类:
public class Control<TItem>
{
public Control(TItem item)
{
}
}
当我试图将匿名类型的对象传递给构造函数时,编译失败:
var objectOfAnonymousType = new { Foo = "bar" };
// cannot compile:
var control1 = new Control(objectOfAnonymousType);
但是,如果我不是通过构造函数,而是通过类之外的泛型方法来实现这一点的,那么它似乎是有效的:
// can
我正在寻找一个类似的概念来推断捕获的泛型类型,类似于下面的方法片段,但是对于捕获泛型类型的类:
public <X, Y, Z> static void someMethod(ObjectInterface<X, Y, Z> object) {
// code that uses inferred generic type parameters X, Y and Z...
}
此代码段中的代码将捕获类型并将它们分配给泛型参数类型X、Y和Z。这允许在代码正文中使用泛型类型变量,并使方法的使用更加灵活。在这个片段中,如果调用方法时没有指定类型(即没有参数化),那么J
看看这三个类。Minatchi允许自己进行扩展,因此它的方法的返回类型也可以扩展。为了说明这一点,我使用了静态方法。
public class Minatchi<T extends Minatchi<?>>{
static public <T extends Minatchi<?>>
List<T> listAll(){
return
(List<T>) query();
}
}
所以我把米纳奇细分为女士
public class Lady
extends Minatchi&l
LINQ中的FirstOrDefault() and FirstOrDefault<string>()有什么区别?
有人能给我一些简单的解释吗?
TypedDataSet ds= codeComponent.GetAllCode("test");
string status = (from s in ds.Codes
where s.Name == "hello"
select s.Remarks).FirstOrDefault();
TypedDataSet ds= codeC
下面是用于测试Type扩展方法的类的片段:
class Something
{
[StringLength(100, MinimumLength = 1, ErrorMessage = "Must have between 1 and 100 characters")]
public string SomePublicString { get; set; }
}
我有以下扩展方法:
public static class TypeExtensions
{
public static TAttributeType GetCustomAttribute<T, TA
请参阅以下简单示例:
public static void main(String[] args) throws FileNotFoundException, IOException {
List<Integer> li = createList();//ok, this mean that ArrayList<Integer> was returned
List<Double> ld = createList();//ok, ArrayList<Double> was returned
}
public static <
下面是我从获得的关于Scala编程的观察结果。
在Scala中,我经常看到抽象的特征模式:
trait Abstract {
type T
def transform(x: T): T
val initial: T
var current: T
}
class Concrete extends Abstract {
type T = String
def transform(x: String) = x + x
val initial = "hi"
var current = initial
}
为什么我要选择抽象的特征模式而不是参数化的泛型?