泛型

泛型

1. 泛型概述

泛型：是JDK5中引入的特性，它提供了编译时类型安全检测机制，该机制允许在编译时检测到非法的类型

它的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数

一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？

顾名思义，就是将类型由原来的具体的类型参数化，然后在使用/调用时传入具体的类型

这种参数类型可以用在类、方法和接口中，分别被称为泛型类、泛型方法、泛型接口

泛型定义格式：

• <类型>:指定一种类型的格式。这里的类型可以看成是形参

• <类型1，类型2>：指定多种类型的格式，多种类型之间用逗号隔开。这里的类型可以看成是实参，并且实参的类型只能是引用类型

泛型的好处:

• 把运行时期的问题提前到了编译期间

• 避免了强制类型的转换

1.2 泛型类

泛型类的定义格式：

• 格式： 修饰符class 类名<类型>{}

• 范例： public class Generic<T>{}

  此处T可以随便写为任意标识、常见的如T、E、K、V等形式的参数常用于表示泛型

学生类

public class Student {
    private String name;
​
    public String getName() {
        return name;
    }
​
    public void setName(String name) {
        this.name = name;
    }
}

 

教师类

public class Teacher {
    private Integer age;
​
    public Integer getAge() {
        return age;
    }
​
    public void setAge(Integer age) {
        this.age = age;
    }
}
​

 

泛型类

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) {
        Student s = new Student();
        s.setName("浪浪");
        System.out.println(s.getName());
​
        Teacher t = new Teacher();
        t.setAge(20);
        System.out.println(t.getAge());
        System.out.println("***************");
​
        Generic<String> g1 = new Generic<>();
        g1.setT("浪浪");
        System.out.println(g1.getT());
​
        Generic<Integer> g2 = new Generic<>();
        g2.setT(20);
        System.out.println(g2.getT());
    }
​
}

1.3泛型方法

泛型方法的定义格式：

• 格式：修饰符<类型> 返回值类型方法名（类型 变量名）{}

工具类

public class Generic {
    public void show(String s){
        System.out.println(s);
    }
    public void show(Integer i){
        System.out.println(i);
    }
    public void show(boolean t){
        System.out.println(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);
    }
}

 

测试类

public class GenericDemo {
    public static void main(String[] args) {
       /* Generic g = new Generic();
        g.show("浪浪");
        g.show(20);
        g.show(true);*/
​
       /* Generic<String> g1 = new Generic<>();
        g1.show("浪浪");
        Generic<Integer> g2 = new Generic<>();
        g2.show(20);
        Generic<Boolean> g3 = new Generic<>();
        g3.show(true);*/
        Generic g = new Generic();
        g.show("浪浪");
        g.show(20);
        g.show(true);
    }
}

1.4 泛型接口

泛型接口的定义格式：

• 格式：修饰符interface接口名<类型>{}

• 范例：public interface Generic<T>{}

接口类

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 GenericDemo {
    public static void main(String[] args) {
        Generic<String> g1 = new GenericImpl<>();
        g1.show("浪浪");
        Generic<Integer> g2 = new GenericImpl<>();
        g2.show(20);
    }
}

1.5 类型通配符

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

• 类型通配符：<?>

• List<?>:表示元素类型未知的List，它的元素可以匹配任何的类型

• 这种带通配符的List仅代表它是各种泛型List的父类，并不能把元素添加到其中

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

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

• List<? extends Number>: 它表示的类型是Number或者其子类型

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

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

• List<? super Number>: 它表示的类型是Number或者其父类型

public class GenericDemo {
    public static void main(String[] args) {
        //类型通配符<?>
        List<?> list1 = new ArrayList<Object>();
        List<?> list2 = new ArrayList<String>();
        List<?> list3 = new ArrayList<Integer>();
        System.out.println("**************");

        //类型通配符的上限  <? extends 类型>
        //List<? extends Number> list4 = new ArrayList<Object>();//错误
        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>(); //错误
    }
}

1.6 可变参数

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

• 格式：修饰符 返回值类型 方法名(数据类型... 变量名){}

• 范例： public static int sum(int... a){}

可变参数注意事项

• 这里的变量其实是一个数组

• 如果一个方法有多个参数，包含可变参数，可变参数要放在最后

测试类

public class ArgsDemo01 {
    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));
        System.out.println(sum(10,20,30,40,50,60,70,80,90,100));

    }

    /*public static int sum(int... a){
        System.out.println(a);
        return 0;
    }*/
    //注意：一个方法如果有多个参数，可变参数要放在最后
    public static int sum(int... a){
        int sum = 0;
        for (int i : a){
            sum +=i;
        }
        return sum;
    }

    /*public static int sum(int a, int b) {
        return a + b;
    }

    public static int sum(int a, int b, int c) {
        return a + b + c;
    }

    public static int sum(int a, int b, int c, int d) {
        return a + b + c + d;
    }*/
}

1.7 可变参数的使用

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):返回一个包含任意数量元素的不可变集合