java\scala,怎麼樣泛型

java的泛型之-

泛型類:

 

 
 
 
  
public class GenericsFoo<T> { 
 
 
  
　　private T x; 
 
 
  
　　public GenericsFoo(T x) { 
 
 
  
　　this.x = x; 
 
 
  
　　} 
 
 
  
　　public T getX() { 
 
 
  
　　return x; 
 
 
  
　　} 
 
 
  
　　public void setX(T x) { 
 
 
  
　　this.x = x; 
 
 
  
　　} 
 
 
  
　　}  
 
 
  
使用=GenericsFoo<String> strFoo=new GenericsFoo<String>("Hello Generics!");
 
 
  
　System.out.println("strFoo.getX="+strFoo.getX());
 

 

泛型方法：

public <T> void f(T x) {

　　System.out.println(x.getClass().getName()); 　　}

調用=　ea.f(" ");

 

scala泛型之--

泛型類：

 

 
 
 
  
class Reference[T] { 
 
 
  
      private var contents: T = _ 
 
 
  
      def set(value: T) { contents = value } 
 
 
  
      def get: T = contents 
 
 
  
} 
 

 

Reference類具備一個叫作T的類型參數來表示他說引用的對象的類型。這個類型在Reference中做爲了變量和函數的參數或者返回類型。

混入trait的限制

 

 
 
 
  
class EmptySet[A <: Ordered[A]] extends Set[A] { 
 
 
  
 
 
 
  
       def contains(x: A) = false 
 
 
  
 
 
 
  
       def incl(x: A): Set[A] = 
 
 
  
 
 
 
  
        new NonEmptySet(x, new EmptySet[A], new EmptySet[A]) 
 
 
  
 
 
 
  
  } 
 

 

Scala中的array能夠取泛型參數（parameterized types）以及類型變量（type variables）來作其元素的類型。這兩項在Scala中是可能的，但在Java中是不可能完成的：

 

 
 
 
  
val xs = new Array[List[Int]](leng)   
 
 
  
val ys = new Array[T](len)  // 這裏的T是類型變量 
 

 

要實現array的泛型，必要的步驟就是讓array變成非變量（non-variant）。Java沒法作到這一點，這是由於其向後兼容的關係。可是，Scala能夠作到。

富領域對象：

trait JpaPersistable[T] extends JpaDaoSupport  {
   def getEntity:T;

   def findAll():List[T] = { 
        getJpaTemplate().find("from " + getEntityClass.getName).toList.asInstanceOf[List[T]]   
   }

   def save():T = {
       getJpaTemplate().persist(getEntity)
       getEntity
   }

   def remove() = {
       getJpaTemplate().remove(getEntity);        
   }
      
   def findById(id:Serializable):T = {
        getJpaTemplate().find(getEntityClass, id).asInstanceOf[T];
   }
   //…more code omitted for readability      
}

使用=

class Person extends JpaPersistable[Person] with java.io.Serializable {

  def getEntity = this
  //…more code omitted for readability
}

協變的定義:    

假設有類G(或者接口和特徵) 和類型T1,T2  。 在T1是T2的子類的狀況下， 若是G<T1> 也是G2<T2>的子類，則類G是協變的。

例子：

 

 
 
 
  
class Link[+T](val head : T, val tail: Link[T]) {
 
 
  
 def prepend[U >: T](newHead: U): Link[U] = new Link(newHead, this)  
 
 
  
} 
 
 
  
 
 
 
  
def main(args : Array[String]){ 
 
 
  
      val ln : Link[Integer]=new Link[Integer](1,null) 
 
 
  
      val lnn : Link[Number]=ln 
 
 
  
      println(lnn.head) 
 
 
  
} 
 

 

Integer是Number的子類，Link[Integer]是Link[Number]的子類，這樣父類型的Link[Number]也能接受Link[Integer]

 

連接：http://doc.chinaunix.net/web/200912/213587.shtml