泛型

1.什么是泛型

        Java 泛型（generics）是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型。泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。

        优点：使用泛型时，在实际使用之前类型就已经确定了，不需要强制类型转换。

        泛型主要使用在集合中

2.泛型类定义

package fanxing;
class Node<T>{
         private T t;
         Node(T t){
                  this.setT(t);
         }
         public T getT() {
                  return t;
         }
         public void setT(T t) {
                  this.t = t;
         }
}
public class Generics {
         public static void main(String[] args) {
                  Node<Integer> n=new Node<Integer>(1);
                  System.out.println(n.getT());
         }
}

注意：

    在使用的时候指定实际类型

    泛型不能使用在静态属性上

    泛型不能为基本类型，否则编译时异常

3.自定义接口泛型

interface List<T>{
         public boolean add(T t);
         public T get();
}
 
public class Generics {
         public static void main(String[] args) {
                  new List<Integer>() {
                          @Override
                          public boolean add(Integer t) {
                                   // TODO Auto-generated method stub
                                   return false;
                          }
                          @Override
                          public Integer get() {
                                   // TODO Auto-generated method stub
                                   return null;
                          }
                  };
         }
}

注意：

    接口中泛型字母只能使用在方法中，不能使用在全局常量中

4.定义泛型方法

class Node{
         public <T> T getT(T t){
                  return t;
         }
         public <T extends List<Integer>> void getTs(T t){
                  System.out.println(t);
         }
}
public class Generics {
         public static void main(String[] args) {
                  Node n=new Node();
                  n.getTs(new List<Integer>() {
                          @Override
                          public boolean add(Integer t) {
                                   // TODO Auto-generated method stub
                                   return false;
                          }
                          @Override
                          public Integer get() {
                                   // TODO Auto-generated method stub
                                   return null;
                          }
                  });
         }
}

注意：

    public <T> T getT(T t) 泛型方法，在返回类型前面使用泛型字母

    public <T extends List<Integer>> void getTs(T t) T 只能是List或者List的子类

5.泛型的继承

全部保留父类的泛型

abstract class A<K,V>{
         K k;
         V v;
         public abstract void add(K k,V v);
}
class B<K,V> extends A<K,V>{
         @Override
         public void add(K k,V v) {
                  super.k=k;
                  super.v=v;
         }
}
public class Generics {
         public static void main(String[] args) {
                  B<Integer,String> b=new B<Integer,String>();
         }
}

部分保留父类的泛型

abstract class A<K,V>{
         K k;
         V v;
         public abstract void add(K k,V v);
}
class B<K> extends A<K,String>{
         @Override
         public void add(K k,String v) {
                  super.k=k;
                  super.v=v;
         }
}
public class Generics {
         public static void main(String[] args) {
                  B<Integer> b=new B<Integer>();
         }
}

不保留父类泛型

abstract class A<K,V>{
         K k;
         V v;
         public abstract void add(K k,V v);
}
class B extends A<Integer,String>{
         @Override
         public void add(Integer k,String v) {
                  super.k=k;
                  super.v=v;
         }
}
public class Generics {
         public static void main(String[] args) {
                  B b=new B();
         }
}

6.通配符

    T、K、V、E 等泛型字母为有类型，类型参数赋予具体的值

    ？未知类型 类型参数赋予不确定值，任意类型

    只能用在声明类型、方法参数上，不能用在定义泛型类上

abstract class Node<T>{
         T t;
         abstract public void add(List<?> l);
}
public class Generics {
         public static void main(String[] args) {
                  Node<?> n;
                  n=new Node<Integer>() {
                          @Override
                          public void add(List<?> l) {
                          }
                  };
         }
}

7.extends/super

上限（extends）

    指定的类必须是继承某个类，或者实现了某个接口（不是implements），即<=

    ? extends List

下限（super）

    即父类或本身

    ？ super List

extends:泛型的上限

class Animal{}
class Dog extends Animal{}
class Cat extends Animal{}
class Fish extends Animal{}
class SmallDog extends Dog{}
class Node{
         public void add(List<? extends Animal> l) {}
}
public class Generics {
         public static void main(String[] args) {
                  new Node().add(new ArrayList<Animal>());
                  new Node().add(new ArrayList<Dog>());
                  new Node().add(new ArrayList<Cat>());
                  new Node().add(new ArrayList<Fish>());
                  new Node().add(new ArrayList<SmallDog>());
                  //new Node().add(new ArrayList<Object>());
         }
}

supper:泛型的上限

class Animal{}
class Dog extends Animal{}
class Cat extends Animal{}
class Fish extends Animal{}
class SmallDog extends Dog{}
class Node{
         public void add(List<? super Dog> l) {}
}
public class Generics {
         public static void main(String[] args) {
                  new Node().add(new ArrayList<Animal>());
                  new Node().add(new ArrayList<Dog>());
                  //new Node().add(new ArrayList<SmallDog>());
         }
}