泛型字母

形式类型参数（formal type parameters）即泛型字母

命名：泛型字母可以随意指定，尽量使用单个的大写字母（有时候多个泛型类型时会加上数字，比如T1，T2）

常见字母（见名知意）

T：TypeK V：Key ValueE：Element

1 泛型声明形式之一：泛型类、接口

需求：定义学生类，其中有学生成绩

整数小数字符串“优秀、良好、合格、不及格”

class Student<T>{private String name;private T score;public Student() {super();}public Student(String name, T score) {super();this.name = name;this.score = score;}public String getName() {return name;}public void setName(String name) {this.name = name;}public T getScore() {return score;}public void setScore(T score) {this.score = score;}@Overridepublic String toString() {return "姓名：" + name + ", 成绩：" + score;}}

public class TestStudentScore {public static void main(String[] args) {Student<Integer> s1 = new Student<Integer>("张三",89);Integer score = s1.getScore();Student<Integer> s2 = new Student<Integer>();// s2.setScore("优秀");s2.setScore(99);}}

声明时的要点

在类/接口上声明的泛型，在本类或本接口中即代表某种类型，可以作为非静态属性的类型、非静态方法的参数类型、非静态方法的返回值类型

在类/接口上声明的泛型不能使用在静态成员上

泛型类的构造器如下：public GenericClass(){}。

而如下是错误的：public GenericClass<E>(){}

泛型类在声明时还可以指定泛型的上限

package com.atguigu.generic.classtype;public class TestPerson {public static void main(String[] args) {// Person<Dog> p = new Person<Dog>();// Person<Object> = new Person<Object>();}}/*class Human<T super Person>{}*/class Person<T extends Person>{private T parnter;//伴侣}class Man extends Person<Woman>{}class Woman extends Person<Man>{}class Dog{}

指定时的要点

当类或接口被使用时，会使用具体的实际类型参数（actual type argument）代替

泛型的指定中不能使用基本数据类型，可以使用包装类替换

泛型如果不指定，将被擦除，泛型对应的类型均按照Object处理，但不等价于Object

例如：

（1）ArrayList<String> list = new ArrayList<String>(); 声明集合变量或创建集合对象，指定泛型

（2）class Dog implements Comparable<Dog>{...} 实现接口时，指定泛型

（3）public void test(ArrayList<Student> list){} 使用泛型类或接口作为形参时，此处指定为学生类型

（4）public void test(ArrayList<?> list){} 使用泛型类或接口作为形参时，此处指定为任意类型

（5）public void test(ArrayList<? extends Person> 使用泛型类或接口作为形参时，此处指定为Person或其子类

（6）public void test(ArrayList<? super Son> 使用泛型类或接口作为形参时，此处指定为Son或其父类

关于泛型类/接口的继承/实现说明

父类有泛型，子类可以选择保留泛型也可以选择指定泛型类型：

子类不保留父类的泛型：按需实现

1) 没有类型 擦除

2) 具体类型

子类保留父类的泛型：泛型子类

1) 全部保留

2) 部分保留

结论：子类必须是“富二代”，子类除了指定或保留父类的泛型，还可以增加自己的泛型

class Father<T1,T2>{}//子类不保留父类的泛型//1)没有类型 擦除class Son extends Father{//等价于class Son extends Father<Object,Object>{}//2)具体类型class Son2 extends Father<Integer,String>{}//子类保留父类的泛型//1)全部保留class Son3<T1,T2> extends Father<T1,T2>{}//2)部分保留class Son4<T2> extends Father<Integer,T2>{}

class Father<T1,T2>{}//子类不保留父类的泛型//1)没有类型 擦除class Son<A,B> extends Father{//等价于class Son extends Father<Object,Object>{}//2)具体类型class Son2<A,B> extends Father<Integer,String>{}//子类保留父类的泛型//1)全部保留class Son3<T1,T2,A,B> extends Father<T1,T2>{}//2)部分保留class Son4<T2,A,B> extends Father<Integer,T2>{}

具体示例代码

class Dog implements Comparable{@Overridepublic int compareTo(Object o) {return 0;}}class Cat implements Comparable<Cat>{@Overridepublic int compareTo(Cat o) {return 0;}}

class MySet<E> implements Collection<E>{@Overridepublic boolean add(E e) {return false;}......}

关于泛型的擦除说明

使用泛型类时未指定泛型的具体类型：类似于Object，不等同于Object

泛型擦除，默认按照Object处理但编译不会类型检查

明确指定Object，编译会按Object类型检查

public class TestGenericErasure {public static void main(String[] args) {//1、使用时：类似于Object，不等同于ObjectArrayList list = new ArrayList();// list.add(new Date());//有风险list.add("hello");test(list);//泛型擦除，编译不会类型检查// ArrayList<Object> list2 = new ArrayList<Object>();// test(list2);//一旦指定Object，编译会类型检查，必须按照Object处理}public static void test(ArrayList<String> list){String str = "";for(String s:list){str += s + ",";}System.out.println("元素:"+str);}}

2 泛型形式之二：泛型方法

如果某个类不是泛型类，而某个方法需要使用泛型

如果某个类是泛型类，但是需要在静态方法上使用泛型

泛型方法的格式：

[访问权限] <泛型字母> 返回类型 方法名([泛型字母 参数名称]) 抛出的异常

package com.atguigu.generic.method;import java.util.List;public class TestMyArrays {public static void main(String[] args) {Integer[] arr = {1,2,3,4};String str = MyArrays.toString(arr);System.out.println(str);}}class MyArrays{public static <T> String toString(T[] arr){String str = "[";int i = 0;for (T t : arr) {str += t;if(i!=arr.length-1){str += ",";}i++;}str += "]";return str;}}

示例：java.util.Arrays类

public static <T> List<T> asList(T... a)

注意：Arrays.asList(…) 方法返回的 List 集合既不是 ArrayList 实例，也不是 Vector 实例。 Arrays.asList(…) 返回值是一个固定长度的 List 集合

public static <T> T[] copyOf(T[] original, int newLength)

public static <T> T[] copyOfRange(T[] original, int from,int to)

public static void main(String[] args) {//public static <T> List<T> asList(T... a)List<String> list = Arrays.asList("hello","world","java");List<Integer> list2 = Arrays.asList(1,2,3);//public static <T> T[] copyOf(T[] original, int newLength)String[] str = {"hello","world","java"};String[] array = Arrays.copyOf(str, 10);//public static <T> T[] copyOfRange(T[] original, int from,int to)String[] as = Arrays.copyOfRange(array, 0, 3);System.out.println(Arrays.toString(str));System.out.println(Arrays.toString(array));System.out.println(Arrays.toString(as));}

注意：

泛型方法可以是静态方法也可以是非静态方法

泛型方法声明泛型时也可以指定上限

package com.atguigu.generic.method;import java.util.ArrayList;import java.util.List;public class TestMyArrays {public static void main(String[] args) {List<Integer> list = new ArrayList<Integer>();list.add(2);list.add(3);list.add(4);list.add(5);list.add(1);MyArrays.sort(list);for (Integer integer : list) {System.out.println(integer);}}}class MyArrays{public static <T extends Comparable<T>> void sort(List<T> list){for(int i=0; i<list.size()-1; i++){for(int j=0; j<list.size()-i-1; j++){Comparable<T> c1 = (Comparable<T>)list.get(j);if(c1.compareTo(list.get(j+1))<0){T temp = list.get(j);list.set(j, list.get(j+1));list.set(j+1, temp);}}}}}

public static void main(String[] args) {/* test(new String());test(new Object());*/test(new Person());test(new Man());}public static <T extends Person> void test(T t){System.out.println(t);}/*public static <T super Person> void test(T t){//错误}*/}class Person{}class Man extends Person{}

public static <T extends Closeable> void free(T... t){for(T c : t){try {if(c!=null){c.close();}} catch (IOException e) {e.printStackTrace();}}}

相关阅读：

java技术自定义类型转换器

JDK1.8新增日期时间类型

java编程语言中的数据类型有哪几种

Java 的抽象类是什么

Java异常处理的概述