泛型的使用及定义

泛型

数据类型参数化

Integer a; // a的数据类型确定是Integer类型

a无法修改数据类型

Object a; a的表面类型确定：Object， 赋值的时候，向上转型，但是使用a的时候，调用真实类型的方法，需要向下转型

a = new Student();

a声明的时候，不确定的数据类型，使用a的时候，确定它的类型

jdk提供了一种机制：泛型机制 <大写的变量名> 声明一个数据类型的变量

泛型大写的变量名常用的名字

• T type（类型）
• E 元素类型
• K key类型
• V value类型

泛型：

• jdk提供的泛型类，泛型方法，使用，给泛型变量赋值
• 定义泛型类，泛型方法

泛型变量赋值：

1. 默认值 Object

2. 手动赋值，使用泛型类，创建类的对象的受给变量赋值

   类<具体的数据类型> 对象名 = new 类<具体的对象类型>();
   

   1. 泛型的数据类型只能是类类型
   2. jdk1.5之后，后面的<>中数据类型可以省略<>不可省略

好处：

​ 添加元素的时候，进行限制，获取元素的时候，不需要进行向下转型

泛型定义

泛型类/接口的定义

public class/interface 类名<泛型变量1[, 泛型变量2...]>{
    // 属性上使用
    private 泛型变量名1 属性名;
    
    // 非静态方法使用 参数类型，返回值类型
    
    // 构造方法使用：参数类型
}

类上的泛型变量无法在静态资源使用

静态的资源使用泛型，在自己先声明泛型变量，再使用

public static <V> V fun(){
    
}

泛型方法的语法

非静态方法：

public <泛型变量名> [泛型变量名/具体类型] 方法名([泛型变量名/具体类型]){
    
}

静态方法：

public static <泛型变量名> [泛型变量名/具体类型] 方法名([泛型变量名/具体类型]){
    
}

泛型方法的泛型变量赋值：

1. 如果泛型变量作为返回值使用，泛型变量的值等于接收方法的返回值变量的数据类型

2. 如果泛型变量作为参数使用，泛型变量的值等于调用方法的传递的参数的类型

   泛型类的泛型变量，创建类对象的时候赋值

   泛型方法的泛型变量的赋值

泛型变量没有继承关系

使用泛型通配符? 表示任意类型 ，但是，如果使用这个通配符，表示这个变量只读，不可添加、修改、删除等操作

限制泛型参数的范围

extends

用于限制泛型类型参数的上限，表示该泛型类参数必须是执行类型或指定类型的子类

示例：

package article;

public class Employee {
    private String id;
    private String name;

    public Employee() {
    }

    public Employee(String id, String name) {
        this.id = id;
        this.name = name;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "id='" + id + '\'' +
                ", name='" + name + '\'' +
                '}';
    }
}

package article;

import java.util.Arrays;

public class Manager extends Employee {

    private Employee[] employees;

    public Manager() {

    }

    public Manager(Employee[] employees) {
        this.employees = employees;
    }

    public Manager(String id, String name, Employee[] employees) {
        super(id, name);
        this.employees = employees;
    }

    public Employee[] getEmployees() {
        return employees;
    }

    public void setEmployees(Employee[] employees) {
        this.employees = employees;
    }

    @Override
    public String toString() {
        return "Manager{" +
                "employees=" + Arrays.toString(employees) +
                '}';
    }
}

package article;

public class Test<T extends Employee> {

    public void printInfo(T t) {
        System.out.println(t);
    }
}

package article;

public class Main {

    public static void main(String[] args) {
        Test<Integer> test = new Test();
    }
}

如果指定的类型不是Employee的子类或本身的时候就会报错，如下图所示

正确代码

package article;

public class Main {

    public static void main(String[] args) {
        Manager manager = new Manager();
        manager.setEmployees(new Employee[]{new Employee("1", "张三"), new Employee("2", "李四")});
        Test<Manager> test = new Test();
        test.printInfo(manager);
    }
}

super

限制泛型类型参数的下限，表示该泛型参数必须是定类型或指定类型的父类

示例参照上面的例子