JavaSE进阶
12.2 自定义泛型
泛型字母
形式类型参数（formal type parameters）即泛型字母
命名：泛型字母可以随意指定，尽量使用单个的大写字母（有时候多个泛型类型时会加上数字，比如T1，T2）
常见字母（见名知意）
- T：Type
- K V：Key Value
- E：Element
12.2.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; } @Override public 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或其父类
关于泛型类/接口的继承/实现说明
父类有泛型，子类可以选择保留泛型也可以选择指定泛型类型：
- 子类不保留父类的泛型：按需实现
- 没有类型 擦除
- 具体类型
- 子类保留父类的泛型：泛型子类
- 全部保留
- 部分保留
结论：子类必须是“富二代”，子类除了指定或保留父类的泛型，还可以增加自己的泛型
|
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{
@Override public int compareTo(Object o) { return 0; }
} class Cat implements Comparable<Cat>{
@Override public int compareTo(Cat o) { return 0; }
} |
|
class MySet<E> implements Collection<E>{
@Override public boolean add(E e) { return false; } ...... } |
关于泛型的擦除说明
使用泛型类时未指定泛型的具体类型：类似于Object，不等同于Object
- 泛型擦除，默认按照Object处理但编译不会类型检查
- 明确指定Object，编译会按Object类型检查
|
public class TestGenericErasure { public static void main(String[] args) { //1、使用时：类似于Object，不等同于Object ArrayList 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); } } |
12.2.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(); } } } |
