java\scala,怎么样泛型

java的泛型之-

泛型类:

 

  
  
  
  
  1. public class GenericsFoo<T> { 
  2.   private T x; 
  3.   public GenericsFoo(T x) { 
  4.   this.x = x; 
  5.   } 
  6.   public T getX() { 
  7.   return x; 
  8.   } 
  9.   public void setX(T x) { 
  10.   this.x = x; 
  11.   } 
  12.   }  
  13. 使用=GenericsFoo<String> strFoo=new GenericsFoo<String>("Hello Generics!");
  14.  System.out.println("strFoo.getX="+strFoo.getX());

泛型方法:

public <T> void f(T x) {

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

调用= ea.f(" ");

 

scala泛型之--

泛型类:

 

  
  
  
  
  1. class Reference[T] { 
  2.       private var contents: T = _ 
  3.       def set(value: T) { contents = value } 
  4.       def get: T = contents 

Reference类具有一个叫做T的类型参数来表示他说引用的对象的类型。这个类型在Reference中作为了变量和函数的参数或者返回类型。

混入trait的限制

 

  
  
  
  
  1. class EmptySet[A <: Ordered[A]] extends Set[A] { 
  2.  
  3.        def contains(x: A) = false 
  4.  
  5.        def incl(x: A): Set[A] = 
  6.  
  7.         new NonEmptySet(x, new EmptySet[A], new EmptySet[A]) 
  8.  
  9.   } 

Scala中的array可以取泛型参数(parameterized types)以及类型变量(type variables)来做其元素的类型。这两项在Scala中是可能的,但在Java中是不可能完成的:

 

  
  
  
  
  1. val xs = new Array[List[Int]](leng)   
  2. 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是协变的。

例子:

 

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

Integer是Number的子类,Link[Integer]是Link[Number]的子类,这样父类型的Link[Number]也能接受Link[Integer]

 

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

你可能感兴趣的:(java,scala,泛型,T)