List<String> s1=new ArrayList<String>();
        s1.add("hello");

s1.add(new Date());

val strs : List[String]=new ArrayList()

class Link[T](val head: T, val tail: Link[T]) 

 List<Integer> li=new ArrayList<Integer>();
        li.add(1);
        List<Number> ln=li;

class Link[+T](val head : T, val tail: Link[T]) {}

def main(args : Array[String]){
      val ln : Link[Integer]=new Link[Integer](1,null)
      val lnn : Link[Number]=ln
      println(lnn.head)
}

class Link[+T](val head : T, val tail: Link[T]) {

 def prepend(newHead: T): Link[T] = new Link(newHead, this)
}

 
实际上，范型变为协变之后就不能把类型参数不加修改的放在成员方法的参数上（这里是newHead）了。但是，通过将成员方法定义为范型，并按照如下所示描述后就可以避免该问题了

class Link[+T](val head: T, val tail: Link[T]) {  
    def prepend[U >: T](newHead: U): Link[U] = new Link(newHead, this)  
} 

abstract class LessThan[T] {
  def apply(a: T, b: T): Boolean
}

val hashCodeLt: LessThan[Any] = new LessThan[Any] {
      def apply(a: Any, b: Any): Boolean = a.hashCode < b.hashCode
    }

    val strLt: LessThan[String] = hashCodeLt

    assert(true ,strLt("a","b"))

Error:Error:line (18)error: type mismatch;
found   : xxx.LessThan[Any]
required: xxx.LessThan[String]
val strLt: LessThan[String] = hashCodeLt
在需要LessThan[Any]的地方使用了LessThan[String]，由此看来LessThan不是逆变的，也不是协变，可以成为非变。
但是在类的定义前加一个 - 符号，使用逆变， 代码则可编译过去了。

abstract class LessThan[-T] {
  def apply(a: T, b: T): Boolean
}

当 scala 使用 implicit 隐式转化时 ，  scala 编辑器发现对象的类型不匹配时，不会直接报错，而会在代码中尝试匹配implicit声明的object, 当然，相同方法签名的类必须唯一。
举个小例子，实现在字符串前后 添加 "**" 的操作。

 1object implicits {
 2
 3  implicit  def strWrapper(s : String)={
 4    new {
 5      def wrap= "**"+s+"**"
 6    }
 7  }
 8  def main(args: Array[String]) {
 9    val s = "hello"
10    println(s.wrap)  // **hello**
11  }
12}

 1object implicits {
 2
 3  class StrWrapper(s : String){
 4    def wrap="**"+s+"**"
 5  }
 6  def main(args: Array[String]) {
 7    implicit def wrapper(s :String)=new StrWrapper(s)
 8    val s = "hello" 
 9    println(s.wrap) // print **hello**
10  }
11}