泛型的概念
泛型：
泛型是一种末知的数据类型，当我们不知道使用什么数据类型的时候，可以使用泛型
泛型也可以看成是一个变量用来接收数据类型
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( "含有泛型的接口，第一种使用方式是：通过定义接口的实现类，实现接口，指定接口的泛型 " + "这个方法传入指定类型参数是：" + 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( "含有泛型的接口第二种使用方式:接口使用什么泛型,实现类就使用什么泛型,类跟着接口走 " + "创建对象的时候传入指定类型参数是：" + 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 ========================================== 一号元素 二号元素 三号元素 四号元素 五号元素