泛型

1.泛型类定义以及使用

public class People<T> {
    private T info;
    
    public People(){
        
    }
    
    public People(T info){
        this.info=info;
    }
    
    public void setInfo(T info){
        this.info=info;
    }
    
    public T getInfo(){
        return this.info;
    }
    
    public static void main(String[] args){
        String name = "zhang";
        int age = 18;
        System.out.println(new People(name).getInfo());
        
        System.out.println(new People(age).getInfo());
    }
}

执行结果：

zhang
18

从代码中可以看到，对于info，我们可以传入String或者int类型的值。

2. 泛型类的子类定义以及使用

public class Student extends People<String>{
    
    public String getInfo(){
        return "sub" +"    " +super.getInfo();
    }

    public static void main(String[] args) {
        Student stu = new Student();
        stu.setInfo("student");
        System.out.println(stu.getInfo());
    }
}

从代码中可以看到，在继承的时候就设定好了String，这里尽量设定，如果不设定编译时会报警告。

3.类型通配符以及类型通配符上限

import java.util.ArrayList;
import java.util.List;

public class TypeWildcard {

    public void test(List<?> c) {
        for (int i = 0; i < c.size(); i++) {
            System.out.println(c.get(i));
        }
    }

    public void test2(List<? extends String> s) {
        for (int i = 0; i < s.size(); i++) {
            System.out.println(s.get(i));
        }
    }

    public static void main(String[] args) {

        TypeWildcard tw = new TypeWildcard();

        List<String> stringList = new ArrayList<>();
        stringList.add("String1");
        stringList.add("String2");

        List<Integer> intList = new ArrayList<>();
        intList.add(3);
        intList.add(4);

        tw.test(stringList);
        tw.test(intList);

        List<String> stringList2 = new ArrayList<>();
        stringList2.add("String5");
        stringList2.add("String6");

        // List<Integer> intList2= new ArrayList<>();
        // intList2.add(7);
        // intList2.add(8);

        tw.test2(stringList2);
        // tw.test2(intList);

    }

}

如代码中，如果test2方法中传入List<int>类型值，就会报下图的错误。以此来达到限制的作用。

4.泛型方法

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

public class GenericMethodTest {
    
    public <T> void fromArrayToCollection(T[] a, Collection<T> c){
        for(T o : a){
            c.add( (T) a);
        }
    }
    
    public <E> void test(Collection<? extends E> from ,Collection<E> to ){
        //这里的方式表明，?是E或者E的子类，即为类型统配符设定了上限
        for(E ele : from){
            to.add( (E) ele);
        }
    }
    
    public <E> void test2(Collection<E> from ,Collection<E> to ){
        for(E ele : from){
            to.add( (E) ele);
        }
    }
    
    public <E,H> void test3(List<H> from ,Collection<E> to ){
        //这里的方式表明，类型形参可以同时声明多个
    }
    
    public <E> void test4(Collection<? super E> from ,Collection<E> to ){
        //这里的方式表明，?是E或者E的父类，即为类型统配符设定了下限
    }

    public static void main(String[] args) {
        GenericMethodTest gmt = new GenericMethodTest();
        
        //这里T就是Object
        Object[] oa = new Object[100];
        Collection<Object> co =new ArrayList<>();
        gmt.fromArrayToCollection(oa, co);
        
        
        //这里T就是String
        String[] sa = new String[100];
        Collection<String> cs =new ArrayList<>();
        gmt.fromArrayToCollection(sa, cs);
        //这里T就是Object
        gmt.fromArrayToCollection(sa, co);
        
        
        Integer[] ia=new Integer[100];
        Float[] fa = new Float[100];
        Number[] na = new Number[100];
        Collection<Number> cn = new ArrayList<>();
        //这里T就是Number
        gmt.fromArrayToCollection(ia, cn);
        //这里T就是Number
        gmt.fromArrayToCollection(fa, cn);
        //这里T就是Number
        gmt.fromArrayToCollection(na, cn);
        //这里T就是Object
        gmt.fromArrayToCollection(na, co);
        //下面T代表String，但是na是一个Number数组，因为Number既不是String类型，也不是String的子类，所以报错
        //gmt.fromArrayToCollection(na, cs);
        
    //====================================================================================    

        //上面内容演示了java自动识别类型
        //有时候防止自动识别错误，需要为设定一个上限，如test方法
        List<Object> ao = new ArrayList<>();
        List<String> as = new ArrayList<>();
        //这里string就是extends object
        gmt.test(as, ao);
        //下面会报错，因为这会让自动识别产生误解
        //gmt.test2(as, ao);
        
    }

}