介绍
泛型是JDK5中引入的特性，它提供了编译时类型安全检测机制，该机制允许在编译时检测到非法的类型
它的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数
一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？
顾名思义，就是将类型由原来的具体的类型参数化，然后在使用/调用时传入具体的类型
这种参数类型可以用在类、方法和接口中，分别被称为泛型类、泛型方法、泛型接口
泛型定义格式：
- <类型>:指定一种类型的格式。这里的类型可以看成是形参
- <类型1,类型2…>:指定多种类型的格式，多种类型之间用逗号隔开。这里的类型可以看成是形参
- 将来具体调用时候给定的类型可以看成是实参，并且
实参的类型只能是引用数据类型
泛型的优点
先看这段代码，这样就报错了！
public class Test {
public static void main(String[] args) {
ArrayList<Object> objectArrayList = new ArrayList<>();
objectArrayList.add("hello");
objectArrayList.add("world");
objectArrayList.add(666);
Iterator<Object> iterator = objectArrayList.iterator();
while (iterator.hasNext()) {
//报错java.lang.ClassCastException:
//java.lang.Integer cannot be cast to java.lang.String
String next = (String) iterator.next();
System.out.println(next);
}
}
}
ArrayList使用了泛型，我们可以指定具体类型的数据
public class Test {
public static void main(String[] args) {
ArrayList<String> objectArrayList = new ArrayList<>();
objectArrayList.add("hello");
objectArrayList.add("world");
//objectArrayList.add(666);不能写，将运行时期的异常提前到了编译期
Iterator<Object> iterator = objectArrayList.iterator();
while (iterator.hasNext()) {
String next = iterator.next();//不用强制转换
System.out.println(next);
}
}
}
使用泛型的好处：
- 将运行时期的异常提前到了编译期
- 避免了类型强制转换（因为指定了固定的类型，所以只能放一种类型）
泛型类（创建对象的时候明确类型）
泛型类的定义格式：T可以写成任意字母，一般使用T、E、K、V
public class Generic<T> {
//
}
泛型类
public class Generic<T> {
private T name;
public void setName(T name) {
this.name = name;
}
public T getName() {
return name;
}
}
泛型测试类
public class GenericTest {
public static void main(String[] args) {
Test<String> test = new Test<>();//指定T为String类型
test.setName("小黑龙");
System.out.println(test.getName());
}
}
泛型方法（调用方法的时候明确类型）
先看看这段代码
public class Test {
public void show(String s) {
System.out.println(s);
}
public void show(Integer s) {
System.out.println(s);
}
public void show(Boolean s) {
System.out.println(s);
}
}
使用泛型类进行改善
public class Test<T> {
public void show(T t) {
System.out.println(t);
}
//但是使用的时候每次都需要去规定T的类型
public static void main(String[] args) {
Test<String> stringTest = new Test<>();
stringTest.show("11111");
Test<Integer> integerTest = new Test<>();
integerTest.show(11111);
Test<Boolean> booleanTest = new Test<>();
booleanTest.show(true);
}
}
泛型方法格式：帅到爆炸！！！酷毙了
public class Test {
public <T> void show(T t) {
System.out.println(t);
}
public static void main(String[] args) {
Test test = new Test();
test.show("1111");
test.show(1111);
test.show(true);
}
}
泛型接口
泛型接口：
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 Test {
public static void main(String[] args) {
GenericImpl<String> generic1 = new GenericImpl<>();
generic1.show("11111");
GenericImpl<Integer> generic2 = new GenericImpl<>();
generic2.show(11111);
}
}
类型通配符<?>
-
List<?>可以表示元素类型未知的List，他的元素可以是任何类型
-
<?>是类型通配符 -
类型通配符的上限：
<? extends 类型>，泛型的类型(等号后面那部分)只能是该类型或该类型的子类 -
类型通配符的上限：
<? super 类型>，泛型的类型只能是该类型或该类型的父类
public class GenericDemo {
public static void main(String[] args) {
//类型通配符<?>
List<?> list1 = new ArrayList<Object>();
List<?> list2 = new ArrayList<Number>();
List<?> list3 = new ArrayList<Integer>();
//类型通配符上限<? extends 类型>
// List<? extends Number> list4 = new ArrayList<Object>();//报错
List<? extends Number> list5 = new ArrayList<Number>();
List<? extends Number> list6 = new ArrayList<Integer>();
//类型通配符下限<? super 类型>
List<? super Number> list7 = new ArrayList<Object>();
List<? super Number> list8 = new ArrayList<Number>();
// List<? super Number> list9 = new ArrayList<Integer>();//报错
}
}