Java 泛型使用基础

所谓泛型，就是变量类型的参数化。

　　泛型是JDK1.5中一个最重要的特征。通过引入泛型，我们将获得编译时类型的安全和运行时更小的抛出ClassCastException的可能。

　　在JDK1.5中，你可以声明一个集合将接收/返回的对象的类型。

　　使用泛型时如果不指明参数类型，即泛型类没有参数化，会提示警告，此时类型为Object。

为什么使用泛型

　　使用泛型的典型例子，是在集合中的泛型使用。

　　在使用泛型前，存入集合中的元素可以是任何类型的，当从集合中取出时，所有的元素都是Object类型，需要进行向下的强制类型转换，转换到特定的类型。

　　比如：

List myIntList = new LinkedList(); // 1

myIntList.add(new Integer(0)); // 2

Integer x = (Integer) myIntList.iterator().next(); // 3

　　第三行的这个强制类型转换可能会引起运行时的错误。

　　泛型的思想就是由程序员指定类型，这样集合就只能容纳该类型的元素。

　　使用泛型：

List<Integer> myIntList = new LinkedList<Integer>(); // 1'

myIntList.add(new Integer(0)); // 2'

Integer x = myIntList.iterator().next(); // 3'

　　将第三行的强制类型转换变为了第一行的List类型说明，编译器会为我们检查类型的正确性。这样，代码的可读性和健壮性也会增强。

泛型使用基础

　　例如：

public interface List <E> 
{
void add(E x);
    Iterator<E> iterator();
}

public interface Iterator<E> 
{
    E next();
boolean hasNext();
}

　　尖括号中包含的是形式类型参数（formal type parameters），它们就如同一般的类型一样，可以在整个类的声明中被使用。

　　当类被使用时，会使用具体的实际类型参数（actual type argument）代替。

　　比如前面的例子中的List<Integer>，那么所有的E将会被Integer类型所代替。

　　泛型类型参数只能被类或接口类型赋值，不能被原生数据类型赋值，原生数据类型需要使用对应的包装类。

　　形式类型参数的命名：尽量使用单个的大写字母（有时候多个泛型类型时会加上数字，比如T1，T2），比如许多容器集合使用E，代表element（元素），Map中用K代表键keys，V代表值。

泛型容器的实现讨论

　　不能用new的形式来创建一个泛型数组。

　　如下：

public class SimpleCollection<T>
{
private T[] objArr;
private int index = 0;

public SimpleCollection()
   {
//Error: Cannot create a generic array of T
      objArr = new T[10];   
   }
}

　　会报错。

　　如何创建一个数组让它接受所有可能的类型呢?

public class SimpleCollection<T>
{
private T[] objArr;

private int index = 0;
public SimpleCollection()
    {
//Error: Cannot create a generic array of T
//objArr = new T[10];

//Warning: Unchecked cast from Object[] to T[]
        objArr = (T[]) new Object[10];

    }

}

　　这个形式虽然可以做到，但是会产生一个警告。

　　查看ArrayList中的实现，可以发现它是使用了一个Object类型的数组：

private transient Object[] elementData;

　　在取出的时候（get方法中）使用了类型转换：

(E) elementData[index];

泛型和子类

List<String> ls = new ArrayList<String>(); // 1

List<Object> lo = ls; // 2

　　一个String类型的List是一个Object类的List吗？

　　不可以，Java编译器将会在第二行产生一个编译错误，因为它们的类型不匹配。

　　这样就避免了如果lo引入加入Object类型的对象，而ls引用试图将其转换为String类型而引发错误。所以编译器阻止了这种可能。

继承泛型类别

　　直接用例子说明：

　　父类：

public class Parent<T1,T2>
{
private T1 foo1;
private T2 foo2;

public T1 getFoo1()
    {
return foo1;
    }
public void setFoo1(T1 foo1)
    {
this.foo1 = foo1;
    }
public T2 getFoo2()
    {
return foo2;
    }
public void setFoo2(T2 foo2)
    {
this.foo2 = foo2;
    }    

}

　　子类继承父类：

public class Child<T1, T2, T3> extends Parent<T1, T2>
{
private T3 foo3;

public T3 getFoo3()
    {
return foo3;
    }

public void setFoo3(T3 foo3)
    {
this.foo3 = foo3;
    }

}

实现泛型接口

　　见例子：

　　泛型接口：

public interface ParentInterface<T1,T2>
{
public void setFoo1(T1 foo1);
public void setFoo2(T2 foo2);
public T1 getFoo1();
public T2 getFoo2();

}

　　子类实现泛型接口：


public class ChildClass<T1,T2> implements ParentInterface<T1, T2>
{
private T1 foo1;
private T2 foo2;

    @Override
public void setFoo1(T1 foo1)
    {
this.foo1 = foo1;

    }
    @Override
public void setFoo2(T2 foo2)
    {
this.foo2 = foo2;
    }
    @Override
public T1 getFoo1()
    {
return this.foo1;
    }
    @Override
public T2 getFoo2()
    {
return this.foo2;
    }

}

限制泛型可用类型

　　在定义泛型类别时，预设可以使用任何的类型来实例化泛型类型中的类型。

　　但是如果想限制使用泛型类别时，只能用某个特定类型或者是其子类型才能实例化该类型时，可以在定义类型时，使用extends关键字指定这个类型必须是继承某个类，或者实现某个接口，也可以是这个类或接口本身。

　　比如下面的例子：

import java.util.ArrayList;import java.util.HashMap;import java.util.LinkedList;import java.util.List;public class ListGenericFoo<T extends List>{    private T[] fooArray;    public T[] getFooArray()    {        return fooArray;    }    public void setFooArray(T[] fooArray)    {        this.fooArray = fooArray;    }        public static void main(String[] args)    {        ListGenericFoo<LinkedList> foo1 = new ListGenericFoo<LinkedList>();        ListGenericFoo<ArrayList> foo2 = new ListGenericFoo<ArrayList>();                //Error: Bound mismatch        //ListGenericFoo<HashMap> foo3 = new ListGenericFoo<HashMap>();                LinkedList[] linkedLists = new LinkedList[10];        foo1.setFooArray(linkedLists);                ArrayList[] arrayLists = new ArrayList[10];        foo2.setFooArray(arrayLists);            }}

　　类声明中：public class ListGenericFoo<T extends List>

　　这样就规定了T必须是一个List继承体系中的类，即实现了List接口的类。

　　此处注意，虽然List是一个接口，但是关键字仍然是extends而不是implements。

　　并且这个List也可以后加括号指明类型，如List<String>等。

　　当没有指定泛型继承的类型或接口时，默认使用T extends Object，所以默认情况下任何类型都可以作为参数传入。

　　当不使用泛型时，比如那些声明时带有<T>的集合类型，如果使用时没有指定类型，泛型类别为Object。不会报错，但是会有警告。

　　<? extends SomeClass>是一个限界通配符（bounded wildcard），？代表了一个未知的类型，并且它是SomeClass的子类，也可以是SomeClass本身。

　　这里面SomeClass是统配符的上界（upper bound of the wildcard）。

　　相应的也有限定下界的，使用关键字super。

　　通配符所代表的其实是一组类型，但具体的类型是未知的。

类型通配声明

　　看下面的代码：

   　GenericFoo<Integer> foo1 = null;     GenericFoo<Boolean> foo2 = null;     //此时foo1只能接受GenericFoo<Integer>类型的实例，foo2只能接受GenericFoo<Boolean>类型的实例

　　如果希望有一个变量foo可以指向下面所有的实例：

      //foo = new GenericFoo<ArrayList>();      //foo = new GenericFoo<LinkedList>();

　　可以这样声明:

    GenericFoo<? extends List> foo = null;    foo = new GenericFoo<ArrayList>();    foo = new GenericFoo<LinkedList>();

　　注意这种形式不同于前面的限制泛型可用类型时提到的形式。

　　前面提到的形式是在声明泛型的类的时候限制了可以用的泛型类型，而现在这种形式是在使用的时候限制了引用的类型，使得引用指向继承了某一个类或接口的类型。

　　如果该应用指向其他类型，则会编译报错：

    //Error:Type mismatch    foo = new GenericFoo<HashMap>();

　　也可以限制引用指向某个类或接口的继承层次之上的类或接口：

　　比如：

    //引用指向继承层次之上   GenericFoo<? super List> ge= null;   ge = new GenericFoo<Object>();

　　使用<?>或是<? extends SomeClass>的声明方式，意味着您只能通过该名称来取得所参考的实例的信息，或者是移除某些信息，但不能增加或者改写它的信息。

　　因为只知道当中放置的是SomeClass的子类，但不确定是什么类的实例，编译器不让您加入信息，理由是，如果可以加入信息的话，那么您就得记得取回的是什么类型的实例，然后转换为原来的类型方可进行操作，这样就失去了使用泛型的意义。

　　另，GenericFoo<? extends Object>等价于GenericFoo<?>，但是它们与GenericFoo<Object>不同，因为GenericFoo<Object>限定了类型为Object。

转载自：http://www.cnblogs.com/mengdd/archive/2013/01/21/2869778.html

秒客网