Java泛型详解

1. 泛型

概述：泛型，即“参数化类型”。就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。
在定义变量的时候不指定变量类型，在后续使用中再定义

泛型的作用：

1. 提高代码复用率
2. 泛型中的类型在使用时指定，不需要强制类型转换（类型安全，编译器会检查类型）

泛型注意事项：
在编译之后程序会采取去泛型化的措施。 也就是说Java中的泛型，只在编译阶段有效。 在编译过程中，正确检验泛型结果后，会将泛型的相关信息擦出，并且在对象进入和离开方法的边界处添加 类型检查和类型转换的方法。也就是说，泛型信息不会进入到运行时阶段

1.1 泛型类

定义一个泛型类

public class ClassName<T>{    
	private T data;
    public T getData() {
    	return data;    
    }
    public void setData(T data) {        
    	this.data = data;    
    }
}

在尖括号中声明一个参数在使用时决定参数类型
例：

public class Person<A> {
    private String name;
    private int age;
    private A data;  // 定义泛型

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public A getData() {
        return data;
    }

    public void setData(A data) {
        this.data = data;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", data=" + data +
                '}';
    }

    public static void main(String[] args) {
        Person<String> p = new Person<>(); // 决定参数类型为String
        p.setData("123456"); // 填入String类型参数设定data
    }
}

1.3 泛型接口

定义泛型接口

public interface IntercaceName<T> {    
	T getData(); 
}

实现接口时，可以选择指定泛型类型，也可以选择不指定， 如下：
指定类型：

public class Interface1 implements IntercaceName<String> {        
	private String text;        
	@Override        
	public String getData() {            
		return text;        
	}    
}

不指定类型：

public class Interface1<T> implements IntercaceName<T> {        
	private T data;        
	@Override        
	public T getData() {            
		return data;        
	}   
}

1.3 泛型方法

指定泛型的范围在这个方法类
定义泛型方法：

private static <T> T methodName(T a, T b) {}

例：

public static void main(String[] args) {
        print(123123);

    }
public static <A> void print(A a) {
    System.out.println(a);
}

1.4 泛型限制类型

在使用泛型时， 可以指定泛型的限定区域 ，

• 例如： 必须是某某类的子类或 某某接口的实现类，格式： <T extends 类或接口1 & 接口2>

public class Demo {
    public static void main(String[] args) {
        Plate<Apple> p = new Plate<>();
    }
}

interface Fruit{}
class Apple implements Fruit{}
class Plate<T extends Fruit> { // 限定泛型为水果类
    T data;
}

1.5 泛型中的通配符

类型通配符是使用？代替方法具体的类型实参。

1. <? extends Parent> 指定了泛型类型的上届

public class Demo {
    public static void main(String[] args) {
        Plate<? extends Fruit> p = new Plate<Apple>();
    }
}

interface Fruit{}
class Apple implements Fruit{}
class Plate<T> {
    T data;
}

2. <? super Child> 指定了泛型类型的下届

public class Demo {
    public static void main(String[] args) {
        Plate<? super Apple> p = new Plate<Fruit>(); // 限定泛型的类型必须为苹果的父类
    }
}

interface Fruit{}
class Apple implements Fruit{}
class Plate<T> {
    T data;
}

3. <?> 指定了没有限制的泛型类型