1. 泛型类

• 泛型类的定义格式：
  • 格式：修饰符 class 类名 <类型>()
  • 例如：public class Generic<T>
    • T 可以使用任意表示，常见的有 T，E，K，V 等。

1.1泛型类

public class Generic2<T> {
    private T t;

    public Generic2() {
    }

    public Generic2(T t) {
        this.t = t;
    }

    public T getT() {
        return t;
    }

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

1.2泛型测试类

    public static void main(String[] args) {
        //创建对象
        Generic2<String> g1=new Generic2<String>();
        g1.setT("张嘉圣杰");
        System.out.println(g1.getT()); // 张嘉圣杰

        Generic2<Integer> g2 =new Generic2<Integer>();
        g2.setT(22);
        System.out.println(g2.getT()); // 22

        Generic2<Boolean> g3 =new Generic2<Boolean>();
        g3.setT(true);
        System.out.println(g3.getT()); // true

    }

2.泛型方法

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

2.1 创建泛型方法

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

2.2 方法测试

    public static void main(String[] args) {

        Generic3 g =new Generic3();

        g.show("张嘉圣杰");
        g.show(22);
        g.show(true);
        /**
         * 张嘉圣杰
         * 22
         * true
         * */
    }

3.泛型接口

• 泛型接口的定义格式：
  • 格式：修饰符 interface 接口名<类型>()
  • 例如：public interface Generic<T>()

3.1 泛型接口

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

3.2 泛型实现类

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

3.3 泛型测试类

    public static void main(String[] args) {

        Generic4 g = new Generic4();

        g.show("张嘉圣杰");
        g.show(22);
        g.show(true);

        /**
         * 张嘉圣杰
         * 22
         * true
         * */
    }

4.类型通配符

类型通配符：<?>

• List<?>: 类型未知的List，仅表示它是各种泛型的父类，并不能把元素添加到其中

类型通配符上限：<? extends 类型>

• List<? extends Number>：类型是Number或者其子类型

类型通配下限：<? super 类型>

• List<? super Number>：类型是Number或者其父类型

5. 可变参数

可变参数又称参数个数可变，变量是一个数组，如果有多个参数，可变参数放在最后

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

5.1可变参数的用法

    public static void main(String[] args) {
        System.out.println(sum(1,2,3,4));
        System.out.println(sum(1,2,3,4,5));
        System.out.println(sum(1,2,3,4,5,6));
        System.out.println(sum(1,2,3,4,5,6,7));
        System.out.println(sum(1,2,3,4,5,6,7,8));
        /**
         * 10
         * 15
         * 21
         * 28
         * 36
         * */
    }

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

5.2可变参数的使用

Arrays：

• public static <T> List<T> asList(T... a)：返回由指定数组支持的固定大小的列表。
• 返回的集合中不能增删元素，可以修改元素

List：

• public static <E> List<E> of(E... elements)：返回包含任意数量元素的不可修改列表
• 返回的集合不能增删改元素

Set：

• public static <E> Set<E> of(E... elements)：返回包含任意数量元素的不可修改的集合
• 在给定的元素中，不能有重复的元素
• 返回的集合不能增删元素

    public static void main(String[] args) {

        List<String> objects = Arrays.asList("Hello", "World", "Java");
        System.out.println(objects); // [Hello, World, Java]

        List<Object> list = List.of("Hello", "World", "Java");
        System.out.println(list); // [Hello, World, Java]

        Set<Object> set = Set.of("Hello", "World", "Java");
        System.out.println(set); // [World, Hello, Java]
    }