Java中的泛型类

泛型类的定义格式：

• 格式：修饰符 class 类名<类型>{}
• 范例：public class Generic<T>{}
  此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型

例：
创建泛类

public class Generic<T> {
    private T t;
    
    public void setT(T t){
        this.t = t;
    }
    public T getT(){
        return t;
    }
}

Demo：

//创建对象
        Generic<String> g1 = new Generic<String>();
        g1.setT("haha");
        System.out.println(g1.getT());//输出 haha

        //创建对象
        Generic<Integer> g2 = new Generic<Integer>();
        g2.setT(10);
        System.out.println(g2.getT());//输出 10

泛型方法

• 格式：修饰符<类型> 返回值类型方法名(类型 变量名){}
• 范例：public <T> void show(T t){}

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

改进：

public class Generic {

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

Demo：

Generic<String> g1 = new Generic<String>();
        g1.show("haha");
        
        Generic<Integer> g2 = new Generic<Integer>();
        g2.show(18);

		//改进后
		Generic g = new Generic();
        g.show("haha");

泛型接口

定义格式：

• 格式：修饰符 interface 接口名<类型>{ }
• 范例：public interface Generic<T>{ }

接口：

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

实现类：

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

Demo：

public class Demo {
    public static void main(String[] args) {

        Generic<String> g1 = new GenericImlp<String>();
        g1.show("haha");

        Generic<Integer> g2 = new GenericImlp<Integer>();
        g2.show(1314);
    }
}

输出：

haha
1314

类型通配符

为了表示各种泛型 List 的父类，可以使用类型通配符

• 类型通配符<?>
• List<?>：表示元素类型未知的List，它的元素可以匹配任何元素
• 这种带通配符的 List 仅代表它是各种泛型 List 的父类，并不能吧元素添加到其中

如果说我们不希望List<?>是如何泛型 List 的父类，只希望它代表某一类泛型 List 的父类，可以使用类型通配符的上限

• 类型通配符上限：<? extends 类型>
• List<? extends Number>：它表示的类型是Number或者其子类型

除了可以指定类型通配符的上限，我们也可以指定类型通配符的下限

• 类型通配符下限：<? super 类型>
• List<? super Number>：它表示的类型是Number或者其父类型

		//类型通配符
        List<?> list1 = new ArrayList<Object>();
        List<?> list2 = new ArrayList<Number>();
        List<?> list3 = new ArrayList<Integer>();
        System.out.println("------------------");

        //类型通配符上限：<? extends 类型>
        //List<? extends Number> list4 = new ArrayList<Object>();//报错，Object是Number的父类
        List<? extends Number> list5 = new ArrayList<Number>();
        List<? extends Number> list6 = new ArrayList<Integer>();
        System.out.println("------------------");

        //类型通配符下限：<? super 类型>
        List<? super Number> list7 = new ArrayList<Object>();
        List<? super Number> list8 = new ArrayList<Number>();
        //List<? super Number> list9 = new ArrayList<Integer>();//报错，Integer是Number的子类

可变参数

可变参数又称参数个数可变，用作方法的形参出现，那么方法参数个数就是可变的了

• 格式：修饰符 返回值类型 方法名(数据类型... a){ }
• 范例：public static int sum(int... a){ }

例：

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

    }

    public static int sum(int... a){//a其实是一个数组，用来存储参数
        int sum = 0;
        for(int i:a){
            sum += i;
        }
        return sum;
    }
}

输出：

30
60
100
150
210
280

关于不可变参数和可变参数同时出现时。

	public static int sum(int... a,int b){//报错
        ......
    }

	public static int sum(int b,int... a){//正常
        ......
    }

不可变参数要放在可变参数前面

可变参数的使用

Arrays工具类中有一个静态方法：

• public static List asList(T… a)：返回由指定数组支持的固定大小的列表
• 返回的集合不能做增删操作，可以做修改操作

List接口中有一个静态方法：

• public static List of(E… element)：返回包含任意数量元素的不可变列表
• 返回的集合不能做增删改操作

Set接口中有一个静态方法：

• public static Set of(E… elements)：返回一个包含任意数量元素的不可变集合
• 在给元素的时候，不能给重复的元素
• 返回的集合不能做增删操作，没有修改的方法