黑马程序员——泛型2

------- android培训、java培训、期待与您交流！ ----------

声明多个泛型类型和通配符

 

若一个类中多个字段需要不同的泛型声明，则在声明类的时候指定多个泛型类型即可；

 

格式：

public interface IDAO<PK, T> {

      

       PKadd(T t);

 

       voidremove(PK id);

 

       voidupdate(PK id, T t);

 

       Tget(PK id);

}

 

在进行引用传递的时候泛型类型必须匹配才可以传递，否则编译不通过；

使用 ，表示未知类型的泛型对象：

List<?> 表示未知元素的List集合；

这种带通配符的List仅表示各种泛型List的父类，并不能把元素添加入集合中；

List<?> list = newArrayList<>(); list.add(1);//ERROR

public void show(List<?> list){}

//表示可接受任意类型的List集合

 、泛型的上限与下限

 

设置泛型对象的上限使用extends,表示参数类型只能是该类型或该类型的子类：

声明对象：类名<?extends 类> 对象名

定义类：类名<泛型标签 extends 类>{}

设置泛型对象的下限使用super,表示参数类型只能是该类型或该类型的父类：

声明对象：类名<?super 类> 对象名称

定义类：类名<泛型标签 extends类>{}

 

public static void  show(List<? extends Number> l){

 

}

public static void  show(List<? super String> l){

 

}

public static voidshow(List<? extends Number> l){}

public static voidshow(List<? super String> l){}

 

泛型的上限
 
public static voidmain(String[] args) {
        Person<Integer> p1= new Person<>();
        p1.setVal(99);
        Person<Double> p2= new Person<>();
        p2.setVal(3.14);
        Person<String> p3= new Person<>();
        p3.setVal("007");
        show(p1);//√
        show(p2);//√
        show(p3);//×
    }
    public static void show(Person<? extends Number> p){//此处限定了Person的参数类型只能是Number或者是其子类，而String并不属于Number。
        System.out.println(p.getVal());
    }
 
泛型的下限
 
    public static void main(String[] args) {
        Person<Integer> p1= new Person<>();
        p1.setVal(99);//Integer
        Person<Double> p2= new Person<>();
        p2.setVal(3.14);//Double
       
        Person<String> p3= new Person<>();
        p3.setVal("007");//String
        Person<Object> p4= new Person<>();
        p4.setVal(newObject());//Object
 
        show(p1);//×
        show(p2);//×
        show(p3);//√
        show(p4);//√
    }
    public static void show(Person<? super String> p){
        System.out.println(p.getVal());
    }

 

很好的例子！

package generic;
 
import java.util.ArrayList;
import java.util.List;
 
public class GenericDemo3 {
    public static void main(String[] args) {
        //因为show方法是用List<?>通配符接收的，所以可以是任意类型！
        List<String> l1 = new ArrayList<>();//newArrayList<String>()
        show(l1);
        List<Double> l2 = new ArrayList<>();
        show(l2);
        List<Number> l3 = new ArrayList<>();
        show(l3); 
        List<Object> l4 = new ArrayList<>();
        show(l4);
        //使用up方法的话接收类型为Number或者其子类
        //up(l1);//错误，因为up方法接收类型为Number或者其子类，l1（String）不符合！
        up(l2);
        up(l3);
        //使用down方法的话接收类型为Number或者其父类
        //down(l2);error
        down(l3);
        down(l4);
    }
public static void down(List<? super Number>l){
       
        for (Object object : l) {
            System.out.println(object);
        }
    }
public static void up(List<? extends Number>l){
       
        for (Object object : l) {
            System.out.println(object);
        }
    }
    public static void show(List<?> l){
       
        for (Object object : l) {
            System.out.println(object);
        }
    }
}

 

 、泛型接口和方法

 

java5后，可以声明泛型接口，声明方式和声明泛型类是一样的。

public interface IDAO<T>{}

泛型接口子类有两种方式：

直接在子类后申明泛型；

在子类实现的接口中给出具体的泛型类型

public class DaoImpl<T>implements IDAO<T>{}

public class DaoImpl implementsIDAO<String>{}

 

 

泛型方法

 

方法中可定义泛型参数，形参的参数类型就是实参的类型。

格式：

<泛型标签> 返回值类型 方法名([泛型标签参数]...)

 

 

publicstatic <T extends Number> List<T> show(T……t){

       return null;

}

.....main.....{

       //Show(new Object[]{});不可以，因为方法参数类型的限定

Show(new Number[]{});

Show(new Integer[]{});

}

 、泛型的嵌套（map例子）

 

package july7;
//泛型加Map的输出！
 
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeMap;
 
 
public class Demo20 {
    public static void main(String[] args) {
        Map<Integer,String> m = new TreeMap<Integer,String>();
       
        m.put(1, "周冬雨");
        m.put(2, "章子怡");
        m.put(3, "章泽天");
       
        System.out.println(m);
       
        //第一种方式，用到了entrySet方法
        Set<Entry<Integer,String>> s = m.entrySet();
        Iterator<Entry<Integer,String>> it = s.iterator();
        while(it.hasNext()){
            Entry<Integer, String> e = it.next();//用到了泛型，这里消除了 强转！
            System.out.println(e.getKey()+"  "+e.getValue());
        }
       
       
        //第二种方法，用到了keySet方法
        Set<Integer> set =m.keySet();
        Iterator<Integer>iter = set.iterator();
        while(iter.hasNext()){
            Integer i = iter.next();//直接写到输出语句，出错！
            System.out.println(i+"  "+m.get(i));
        }
    }
}