Java的泛型

泛型

public class GenericDemo {
    public static void main(String[] args) {
        Collection collection =new ArrayList();

        //添加元素
        collection.add("java");
        collection.add(12);

        System.out.println("-----------------");
        System.out.println(collection);
        for (Object o: collection) {
            System.out.println(o);
        }

        System.out.println("--------------------");
        Iterator iterator=collection.iterator();
        while (iterator.hasNext()){
            Object next = iterator.next();
            System.out.println(next);
        }
    }
}

这是没有使用泛型的情况，可以发现任何对象都可以装进去，但是一旦我们修改为

Collection<String> collection =new ArrayList();

就表示只能接收String对象,而不是所有都能装进去(12就不能装进去，会报错)

泛型类

public class Generic<T> {
    private T t;

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }
}

//测试类
public class GenericDemo {
    public static void main(String[] args) {
       Generic<String> g1=new Generic<>();
       g1.setT("王五");
       System.out.println(g1.getT());

        Generic<Integer> g2=new Generic<>();
        g2.setT(12);
        System.out.println(g2.getT());
    }
}

泛型方法

public class Generic<T> {
    public void show(T t){
        System.out.println(t);
    }
}

//测试类
public class GenericDemo {
    public static void main(String[] args) {
       Generic<String> generic=new Generic<>();
       generic.show("zhangsan");

       Generic<Integer> generic1=new Generic<>();
       generic1.show(12);
    }
}

//public class Generic {
//    public void show(T t){
//        System.out.println(t);
//    }
//}

public class Generic {
    public<T> void show(T t){
        System.out.println(t);
    }
}

//测试类
public class GenericDemo {
    public static void main(String[] args) {
       Generic generic=new Generic();
        generic.show("zhangsan");
        generic.show(15);
    }
}

泛型接口

public interface Generic<T> {
    void show(T t);
}

public class GenericImpl<T> implements Generic<T>{
    @Override
    public void show(T t) {
        System.out.println(t);
    }
}

public class test {
    public static void main(String[] args) {
        GenericImpl generic=new GenericImpl();
        generic.show("wangwu");

        Generic<Integer> generic1=new GenericImpl<>();
        generic1.show(12);
    }
}

类型通配符

public class GenericDemo {
    public static void main(String[] args) {
        //类型通配符:?
        List<?> list=new ArrayList<Object>();
        List<?> list1=new ArrayList<Number>();
        List<?> list2=new ArrayList<Integer>();
        System.out.println("------------------");
        
        //类型通配符的上限:
        List<? extends  Number> list3=new ArrayList<>();
        List<? extends  Number> list4=new ArrayList<Integer>();
        
        //类型通配符的下限:
        List<? super Number> list5=new ArrayList<Object>();
        List<? super Number> list6=new ArrayList<Number>();
    
        
    }
}

可变参数

public class test2 {
    public static void main(String[] args) {
        System.out.println(sum(10, 20, 30));
        System.out.println(sum(10, 20, 30,40));
        System.out.println(sum(10, 20, 30,50));

    }
    public static int sum(int... a){
        int num=0;

        for (Integer i: a){
            num+=i;
        }
        return num;
    }
}

可变参数的使用