泛型类，泛型方法，泛型接口，可变参数

泛型类

// definition
public class Student<E> {
    private E t;

    public E getT() {
        return t;
    }
    public void setT(E t) {
        this.t = t;
    }
}

// use
        Student<String> s = new Student<>();
        s.setT("iwodo");
        System.out.println(s.getT());
        
        Student<Integer> p = new Student<>();
        p.setT(89);
        System.out.println(p.getT());

泛型方法

// definition
public class Student{
    // 泛型方法
    public <E> void show(E e){
        System.out.println(e);
    }
}

// use
        Student s = new Student();
        s.show("nihao");
        s.show(12);
        s.show(true);
        s.show(12.34);

泛型接口

// 泛型接口
public interface jie_kou<T> {
    public abstract void show(T t);
}

// 实现类
public class Student<T> implements jie_kou<T>{
    @Override
    public void show(T t) {
        System.out.println(t);
    }
}

可变参数，类型通配符

可变参数

// use
System.out.println(sum(10,20));
System.out.println(sum(10,20,30));
// definition
public static int sum(int ... a){		// 这里的 a 是一个数组, 包含了所有传进来的参数
    int sum = 0;
    for(int i : a){
        sum += i;
    }
    return sum;
}

// 如果还想有其他的参数				可变参数 必须是最后一个参数

System.out.println(sum("10",20));
System.out.println(sum("20",20,30));

public static int sum(String s,int ... a){
    int sum = 0;
    for(int i : a){
        sum += i;
    }
    return sum;
}

类型通配符

List<? extends Number>	表示Number及其子类型
List<? super Number> 表示Number及其父类型

可变参数使用

// 泛型方法且静态, 函数返回类型是 List<T>,List<T>,Set<T>
public static<T> List<T> asList(T ... a)  
List<String> list = Arrays.asList("hello","world","java"); // 返回一个固定大小的集合, 可以修改元素,但不可增删

public static<T> List<T> of(T ... elements)
List<String> list = list.of("hello","world","java","world"); // 返回不可变集合, 不可增删改

public static<T> Set<T> of(T ... elements)
Set<String> set = Set.of("hello","world","java"); // 返回不可变集合, 不可增删, Set没有修改元素的方法