Java泛型

Java泛型：

泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。 Java语言引入泛型的好处是安全简单。

泛型的好处是在编译的时候检查类型安全，并且所有的强制转换都是自动的或者隐式的，提高代码的重用性。

规则：

1. 泛型的类型参数只能是类类型（包括自定义类），不能是简单类型。（注意类型参数只能代表引用型类型，不能是原始类型（像int,double,char的等）。）

2、每一个类型参数声明部分包含一个或多个类型参数，参数间用逗号隔开。一个泛型参数，也被称为一个类型变量，是用于指定一个泛型类型名称的标识符。

4、泛型的参数类型可以使用extends语句，例如<T extends superclass>。习惯上称为“有界类型”。

5、泛型的参数类型可以是通配符类型。例如Class<?> classType = Class.forName("java.lang.String");

6、所有泛型方法声明都有一个类型参数声明部分（由尖括号分隔），该类型参数声明部分在方法返回类型之前（在下面例子中的<E>）。public <T> void show(T x) {

class Fanx<T>{ private T data; public Fanx(T data) { this.data=data; } public T getData() { return data; } public void setData(T data) { this.data = data; } public void showType() {         System.out.println("T: " + data.getClass().getName()+"   data:"+this.data);     } } public class Main { public static void main(String [] args) { Fanx<Integer> fanx=new Fanx<Integer>(100); fanx.showType(); Fanx<String> fanx2=new Fanx<String>("hello"); fanx2.showType(); } }

输出结果： T: java.lang.Integer   data:100 T: java.lang.String   data:hello

 

1. class GenericsF<T> 声明了一个泛型类，这个T没有任何限制，实际上相当于Object类型，实际上相当于 class GenericsF<T extends Object>。
2. 与Object泛型类相比，使用泛型了锁定义的类在声明和构造函数的时候，可以使用“<实际类型>”来一并指定泛型类型持有者的真实类型。类如GenericsF<Double> douF=new GenericsF<Double>(new Double("33"));
3. 也可以在构造对象的时候不使用尖括号指定泛型类型的真实类型，但是你在使用该对象的时候，就需要强制转换了。比如：GenericsF douF=new GenericsF(new Double("33"));

限制泛型

在上面的例子中，由于没有限制class GenericsF<T>类型持有者T的范围，实际上这里的限定类型相当于Object，这和“Object泛型”实质是一样的。限制比如我们要限制T为集合接口类型。只需要这么做：

class GenericsF<T extends Collection>，这样类中的泛型T只能是Collection接口的实现类，传入非Collection接口编译会出错。

注意：<T extends Collection>这里的限定使用关键字extends，后面可以是（collection）类也可以是接口。但这里的extends已经不是继承的含义了，应该理解为T类型是实现Collection接口的类型，或者T是继承了XX类的类型。

public class CollectionGenFoo<T extends Collection> {     private T x;     public CollectionGenFoo(T x) {         this.x = x;     }     public T getX() {         return x;     }     public void setX(T x) {         this.x = x;     } }	public class Main{     public static void main(String args[]) {   CollectionGenFoo<ArrayList> listFoo = null;   listFoo = new CollectionGenFoo<ArrayList>(new ArrayList());         System.out.println("实例化成功!");     } }
分别写在两个文件           输出结果：

多接口限制：

<T extends SomeClass & interface1 & interface2 >

public class Demo<T extends Comparable & Serializable> {

    // T类型就可以用Comparable声明的方法和Seriablizable所拥有的特性了

}

泛型方法

是否拥有泛型方法，与其所在的类是否泛型没有关系。要定义泛型方法，只需将泛型参数列表置于返回值前

public class A{ public <T> void show(T x) { System.out.println(x.getClass().getName()+": "+x); } public static void main(String[] args) { A a=new A(); a.show("hello"); a.show('a'); a.show(3); a.show(a); } }

输出结果： java.lang.String: hello java.lang.Character: a java.lang.Integer: 3 aaa.A: aaa.A@7852e922

 

java泛型中<?>和<T>区别

public class A{ public static void printColl(ArrayList<?> al){         Iterator<?> it = al.iterator();         while(it.hasNext())         {                 System.out.print(it.next().toString());         } }      public static  void main(String[] args) { ArrayList<Integer> arr=new ArrayList<>(); arr.add(1);arr.add(2);arr.add(3); printColl(arr); ArrayList<Character> acc=new ArrayList<>(); acc.add('a');acc.add('b');acc.add('c'); printColl(acc); } }

输出结果：123abc   T自定义泛型和?通配符泛型   ？和T都表示不确定的类型  但如果是T的话 函数里面可以对T进行操作 比如while里面可以这样写 T t = it.next(); System.out.println(t);

加了泛型了参数不能调用与参数类型有关的方法比如“+”；如打印出任意参数化类型集合中的所有内容，就适合用通配符泛型<?>
public static void printCollecton(Collection <?> collection)
{
    for(Object obj: collection)
   {
       System.out.println(obj);
   }
}

泛型三种：
ArrayList<T> al=new ArrayList<T>();指定集合元素只能是T类型
ArrayList<?> al=new ArrayList<?>();集合元素可以是任意类型，这种没有意义，一般是方法中，只是为了说明用法
ArrayList<? extends E> al=new ArrayList<? extends E>();
            泛型的限定：
               ? extends E:接收E类型或者E的子类型。
               ？super E:接收E类型或者E的父类型。