简单java-泛型

泛型是一种未知的数据类型，当不明确是什么数据类型时，就可以使用泛型

 创建集合时，使用泛型 
         好处： 避免了存储过后，取出时的类型转换问题，存什么类型，就去什么类型 
                    把运行时异常提升到编译时错误 

定义含有泛型的类

 例如
public class test {
    public static void main(String[] args) {
        genericity<Integer> f=new genericity<Integer>();  //jdk1.8后,后面的Integer可以省略
        f.set(6);
        System.out.print(f.get());
    }
}
class genericity<E>{
    private E i;
    public void set(E i){
        this.i=i;
    }
    public E get(){
        return i;
    }
}

泛型方法

public class test {
    public static void main(String[] args) {
        Integer sz[] = { 1, 2, 3, 4, 5, 6 };
        String str[]={"rt","trt","rtrtrt","rrrw"};
        test.fun(sz);
        test.fun(str);
    }
            注意<T> 该泛型符号不能丢了,且泛型符号介于修饰符和返回值之间
    public static <T> void fun(T[] t) {
        for (int i=0;i<t.length;i++) {
            System.out.println(t[i]);
        }
    }
}

泛型接口

public class test {
    public static void main(String[] args) {
        F4<Integer> f = new FF<Integer>();    //如果父类接口的泛型确定了，则子类实例化不用泛型.例子如下代码
        f.fu(5);
    }
}

interface F4<T> {         //接口限定泛型
    public void fu(T i);
}

class FF<T> implements F4<T> {  
    public void fu(T i) {
        System.out.println(i);
    }
}


子类实现父类接口时也要实现泛型，也可以具体写出父类具体的泛型而子类不用写

  如


public class test {
    public static void main(String[] args) {
        F4<String> f=new FF();
        f.fu("hello");
    }
}
interface F4<T> {         //接口限定泛型
    public void fu(T i);
}

class FF implements F4<String> {   //子类实现父类接口时也要实现泛型     也可以具体写出父类具体的泛型而子类不用写如  FF implements F4<String>
    public void fu(String i) {
        System.out.println(i);
    }
}

通配符

 ？  代表任意的数据类型 
  不能作为创建对象使用，只能作为方法的参数 
   
   如果我们要遍历一个集合
   但不知道集合的泛型是什么的情况下，可以用通配符 
   如 

public class test {
    public static void main(String[] args) {
        ArrayList arrayList=new ArrayList();
        arrayList.add("ff");
        arrayList.add("hh");
        arrayList.add("yyy");
        s(arrayList);
        ArrayList arrayList2=new ArrayList();
        arrayList2.add(4);
        arrayList2.add(7);
        arrayList2.add(99);
        s(arrayList2);
    }
       这里只能用通配符的方式打印，有人会想到用泛型做参数，但是不行
    public static void s(ArrayList<?> t){
        Iterator i=t.iterator();
        while (i.hasNext()){
            System.out.println(i.next());
        }
    }
}  
  注意注意：  在使用了通配符的方法里，  不能去设置值 
               也就是说不能添加，修改它，但可以删除和获取

重点

   泛型上限    例如   ？extends Number 
            表示只有Number及其子类才可以使用该方法
   
			public static void s(ArrayList<? extends Number> t){ 
			        for (int i=0;i<t.size();i++){
			           System.out.println(t.get(i));
			       }
			    } 
 
 泛型下限  例如  ? super Integer   
               指的是只有Integer及其父类才可以使用 
                
         这里强调，是 ，泛型！泛型！泛型！ 如果传过来的参数类型本身没有设置泛型，
         那么，泛型上限就对实参没有限制了，依然可以使用该方法，因为它没有泛型