泛型的概念
泛型：
泛型是一种末知的数据类型，当我们不知道使用什么数据类型的时候，可以使用泛型
泛型也可以看成是一个变量用来接收数据类型
E e：Element元素
T t：Type类型
是否使用泛型的对比
不使用泛型
/** * 创建集合对象，不使用泛型 * 好处： * 集合不使用泛型，默认的类型就是Object类型，可以存储任意类型的数据。 * 弊端： * 不安全，会引发异常 */
好处（举例）：
public class Demo01Generic {
public static void main(String[] args) {
// 集合不使用泛型
ArrayList arrayList = new ArrayList();
// 向集合中添加数据，用于测试，这里添加了String类型的数据，和int类型的数据
arrayList.add("ABC");
arrayList.add(123);
// 使用迭代器遍历集合
// 第一步：获取送代器的实现类对象，并使用Iterator接口接收
Iterator ite = arrayList.iterator();
// 第二步：使用hasNext方法和next方法遍历集合，取出的元素的类型默认是Object类型
while (ite.hasNext()) {
System.out.println(
ite.next()
);
}
}
}
输出结果： ABC 123
弊端（举例）：
public class Demo02Generic {
public static void main(String[] args) {
ArrayList arrayList = new ArrayList();
arrayList.add("ABC");
arrayList.add(123);
Iterator ite = arrayList.iterator();
while (ite.hasNext()) {
// 取出的数据，默认是Object类型
Object object = ite.next();
// 假如想使用String特有的length方法来获取字符串的长度，是不可以的
// 需要将Object类型向下转型为String类型才能使用它的特有方法
// 但是集合里面还有数据类型是Integer的数据，所以不能进行向下转型为String类型，
// 如果强行转换，那么在运行是会抛出ClassCastException异常
String string = (String)object;
System.out.println(string.length());
}
}
}
抛出错误：
Exception in thread "main" java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
at XXXXXX.main(Demo02Generic.java:36)
使用泛型
/** * 创建集合对象，使用泛型 * 好处： * 1、避免了类型转换的麻烦，存储的是什么类型，取出的就是什么类型 * 2、把运行期昇常，提升到了编译期 * 弊端： * 泛型是什么类型,只能存储什么类型的数据 */
好处及弊端（举例）：
import java.util.ArrayList;
import java.util.Iterator;
public class Demo03Generic {
public static void main(String[] args) {
ArrayList<String> arrayList = new ArrayList<>();
arrayList.add("ABC");
// 假如添加的数据的类型不是String类型，
// 那么会抛出错误：方法 java,util.Collection.add(java.lang.String)不适用
// arrayList.add(123);
Iterator<String> ite = arrayList.iterator();
while (ite.hasNext()) {
String string = ite.next();
System.out.println(
string.length()
);
}
}
}
输出结果： 3
定义和使用含有泛型的类
说明
/**
* 泛型，用来灵活地将数据类型应用到不同的类、方法、接口当中。将数据类型作为参数进行传递。
*
* 定义和使用含有泛型的类：
* 定义格式：
* 修饰符 class 类名称<代表泛型的变量> { . . . }
*/
举例
创建一个含有泛型的类
public class GenericClass<E> {
private E name;
public E getName() {
return name;
}
public void setName(E name) {
this.name = name;
}
}
使用这个类
public class DemoGenericClass {
public static void main(String[] args) {
// 使用泛型
GenericClass<String> name1 = new GenericClass<>();
name1.setName("使用泛型：这里只能添加指定类型的数据");
String string = name1.getName();
System.out.println(string);
// 不使用泛型，默认是Object类型
GenericClass name2 = new GenericClass();
name2.setName("不使用泛型：这里能添加不同类型的数据");
Object object = name2.getName();
System.out.println(object);
}
}
输出结果： 使用泛型：这里只能添加指定类型的数据 不使用泛型：这里能添加不同类型的数据
定义和使用含有泛型的方法
说明
/**
* 定义含有泛型的方法:泛型定义在方法的修饰符和返回值类型之间
* 格式:
* 修饰符 <泛型> 返回值类型 方法名(参数列表(使用泛型)){
* 方法体
* };
*
* 含有泛型的方法,在调用方法的时候确定泛型的数据类型
* 传递什么类型的参数,泛型就是什么类型
*/
举例
定义含有泛型的方法
public class GenericMethod {
/**
* 定义一个含有泛型的方法
*/
public <W> String method1(W w) {
return "一个含有泛型的方法：" + w;
}
/**
* 定义一个含有泛型的静态方法
*/
public static <Z> String method2(Z z) {
return "一个含有泛型的静态方法：" + z;
}
}
使用这两个方法
public class DemoGenericMethod {
public static void main(String[] args) {
// 创建类对象
GenericMethod gm = new GenericMethod();
// 调用含有泛型的普通方法
System.out.println(
gm.method1(666)
);
System.out.println(
gm.method1("ABC")
);
System.out.println(
gm.method1(0.999)
);
// 调用含有泛型的静态方法
// 可以使用gm.method2()来调用静态方法
// 不推荐使用创建对象来调用静态方法，推荐直接用类名称来调用
System.out.println(
GenericMethod.method2(666)
);
System.out.println(
GenericMethod.method2("ABC")
);
System.out.println(
GenericMethod.method2(0.999)
);
}
}
输出结果： 一个含有泛型的普通方法：666 一个含有泛型的普通方法：ABC 一个含有泛型的普通方法：0.999 一个含有泛型的静态方法：666 一个含有泛型的静态方法：ABC 一个含有泛型的静态方法：0.999
定义和使用含有泛型的接口
说明
/** * 1、含有泛型的接口，第一种使用方式是：通过定义接口的实现类，实现接口，指定接口的泛型 * * 2、含有泛型的接口第二种使用方式:接口使用什么泛型,实现类就使用什么泛型,类跟着接口走 * 就相当于定义了一个含有泛型的类,创建对象的时候确定泛型的类型 */
举例1
定义一个含有泛型的接口
public interface GenericInterface<I> {
/**
* 接口的抽象方法
* @param i 泛型参数
*/
public abstract void method(I i);
}
创建接口实现类
public class GenericInterfaceImplement implements GenericInterface<String>{
@Override
public void method(String s) {
System.out.println(
"含有泛型的接口，第一种使用方式是：通过定义接口的实现类，实现接口，指定接口的泛型\n"
+ "这个方法传入指定类型参数是：" + s
);
}
}
测试含有泛型的接口
public class DemoGenericInterfaceImplement {
public static void main(String[] args) {
GenericInterfaceImplement gii = new GenericInterfaceImplement();
gii.method("666999");
}
}
输出结果： 含有泛型的接口，第一种使用方式是：通过定义接口的实现类，实现接口，指定接口的泛型 这个方法传入指定类型参数是：666999
举例2
创建一个含有泛型的接口
public interface GenericInterface<I> {
/**
* 接口的抽象方法
* @param i 泛型参数
*/
public abstract void method(I i);
}
创建接口的实现类
public class GenericInterfaceImplement<I> implements GenericInterface<I>{
@Override
public void method(I i) {
System.out.println(
"含有泛型的接口第二种使用方式:接口使用什么泛型,实现类就使用什么泛型,类跟着接口走\n"
+ "创建对象的时候传入指定类型参数是：" + i
);
}
}
测试含有泛型的接口
public class DemoGenericInterfaceImplement {
public static void main(String[] args) {
GenericInterfaceImplement01<Integer> gii = new GenericInterfaceImplement01<>();
gii.method(2020);
}
}
泛型通配符
说明
/** * 通配符基本使用泛型的通配：不知道使用什么类型来接收的时候，此时可以使用?，?表示未知通配符，即：表示任意的数据类型。 * 使用方式： * 不能创建对象使用，只能作为方法的参数使用。 * 注意： * 一但使用泛型的通配符，那么，只能使用Object类中的共性方法，集合中元素的自身方法无法使用。 * */
举例
创建一个遍历集合的方法
public class IteratorArrayList {
// 由于不知道接收的ArrayList的数据是什么类型，所以使用泛型通配符?
public static void printArrayList(ArrayList<?> arrayList) {
// 使用迭代器遍历集合
Iterator<?> ite = arrayList.iterator();
while (ite.hasNext()) {
// next()方法取出的元素是Object，可以接收任意的数据类型
Object object = ite.next();
System.out.println(object);
}
}
}
测试这个方法
public class DemoIteratorArrayList {
public static void main(String[] args) {
// Integer类型数据
ArrayList<Integer> arrayList1 = new ArrayList<>();
arrayList1.add(1);
arrayList1.add(2);
arrayList1.add(3);
arrayList1.add(4);
arrayList1.add(5);
// 遍历Integer数据类型的集合
IteratorArrayList.printArrayList(arrayList1);
System.out.println("==========================================");
// String数据类型
ArrayList<String> arrayList2 = new ArrayList<>();
arrayList2.add("一号元素");
arrayList2.add("二号元素");
arrayList2.add("三号元素");
arrayList2.add("四号元素");
arrayList2.add("五号元素");
// 遍历String数据类型的集合
IteratorArrayList.printArrayList(arrayList2);
}
}
输出结果： 1 2 3 4 5 ========================================== 一号元素 二号元素 三号元素 四号元素 五号元素
来源：https://www.cnblogs.com/liyihua/p/12185433.html