实例：
定义一个含有泛型的类：
使用这个泛型类：
运行结果：
不写泛型默认为Object类型
11
定义一个含有泛型方法的类：
运行结果：
123
ashda
true
6.6
============
静态方法，不建议创建对象使用
静态方法
定义一个含有泛型的接口：
使用实现类：
运行结果：
字符串
2626
泛型的通配符使用方法：
定义一个类：
使用这个类：
111
222
AAA
BBB
定义一个含有泛型的类：
package JiHe.FinXing;
/*
定义一个含有泛型的类，模拟ArrayList集合
泛型是一个未知对的数据类型，当我们不确定什么什么数据类型的时候，可以使用泛型
泛型可以接收任意的数据类型，可以使用Integer,String,Student...
创建对象的时候确定泛型的数据类型
*/
public class GenericClass<E> {
private E name;
public void setName(E name) {
this.name = name;
}
public E getName() {
return name;
}
}
使用这个泛型类：
package JiHe.FinXing;
public class Demo01GenericClass {
public static void main(String[] args) {
//不写泛型默认为Object类型
GenericClass gc = new GenericClass();
gc.setName("不写泛型默认为Object类型");
Object obj = gc.getName();
System.out.println(obj);
//创建GenericClass对象，泛型使用Integer类型
GenericClass<Integer> gc2 = new GenericClass<>();
gc2.setName(11);
Integer name = gc2.getName();
System.out.println(name);
//创建GenericClass对象，泛型使用String类型
GenericClass<String> gc3 = new GenericClass<>();
gc3.setName("这是一个String类型的字符串");
String str = gc3.getName();
System.out.println(str);
}
}
运行结果：
不写泛型默认为Object类型
11
这是一个String类型的字符串
package JiHe.FinXing;
/*
定义含有泛型的方法：泛型定义在方法的修饰符和返回值类型之间
格式：
修饰符 <泛型> 返回值类型 方法名(参数列表(使用泛型)){
方法体;
}
含有泛型的方法，在调用方法的时候确定泛型的数据类型
传递什么类型的参数，泛型就是什么类型
*/
public class GenericMethod {
//定义一个含有泛型的方法
public <M> void method01(M m){
System.out.println(m);
}
//定义一个含有泛型的静态方法
public static <S> void method02(S s){
System.out.println(s);
}
}
使用这个类：
package JiHe.FinXing;
public class Demo02GenericMethod {
public static void main(String[] args) {
//创建GenericMethod对象
GenericMethod gm = new GenericMethod();
/*
调用含有泛型的方法method01
传递什么类型，泛型就是什么类型
*/
gm.method01(123);
gm.method01("ashda");
gm.method01(true);
gm.method01(6.6);
System.out.println("============");
gm.method01("静态方法，不建议创建对象使用");
//静态方法，通过类名.方法名(参数)可以直接使用
GenericMethod.method02("静态方法");
GenericMethod.method02(56226);
}
}
运行结果：
123
ashda
true
6.6
============
静态方法，不建议创建对象使用
静态方法
56226
package JiHe.FinXing;
/*
定义含有泛型的接口
*/
public interface GenericInterface<I> {
public abstract void method03(I i);
}
定义一个实现类GenericInterfaceImpl1使用这个接口：
package JiHe.FinXing;
/*
含有泛型的接口，第一种使用方式：定义接口的实现类，实现接口，指定接口的泛型
*/
public class GenericInterfaceImpl1 implements GenericInterface<String>{
@Override
public void method03(String s) {
}
}
定义一个实现类GenericInterfaceImpl2使用这个接口：
package JiHe.FinXing;
/*
含有泛型的接口第二种使用方式，接口使用什么泛型，实现类就使用什么泛型，类跟着接口走
就想当与定义了一个含有泛型的类，创建对象的时候确定了泛型的类型
*/
public class GenericInterfaceImpl2<I> implements GenericInterface<I>{
@Override
public void method03(I i) {
}
}
使用实现类：
package JiHe.FinXing;
/*
测试含有泛型的接口
*/
public class Demo03GenericInterface {
public static void main(String[] args) {
//创建GenericInterfaceImpl1对象
GenericInterfaceImpl1 gi1 = new GenericInterfaceImpl1();
gi1.method03("字符串");
//创建GenericInterfaceImpl2对象
GenericInterfaceImpl2<Integer> gi2 = new GenericInterfaceImpl2<>();
gi2.method03(2626);
GenericInterfaceImpl2<Double> gi3 = new GenericInterfaceImpl2<>();
gi3.method03(6.6);
}
}
运行结果：
字符串
2626
6.6
定义一个类：
package JiHe.FinXing;
import java.util.ArrayList;
import java.util.Iterator;
/*
泛型的通配符：
？：代表任意的数据类型
使用方法：
不能直接创建对象
只能作为方法的参数使用
*/
public class Demo04Generic {
public static void main(String[] args) {
ArrayList<Integer> list01 = new ArrayList<>();
list01.add(111);
list01.add(222);
ArrayList<String> list02 = new ArrayList<>();
list02.add("AAA");
list02.add("BBB");
printArray(list01);
printArray(list02);
}
/*
定义一个方法，能遍历所有类型的ArrayList集合
这时候我们不知道ArrayList集合使用什么数据类型，可以泛型的通配符？来接收数据类型
注意：
泛型没有继承概念的 不能使用Object，只能用通配符？
*/
public static void printArray(ArrayList<?> list){
//使用迭代器遍历
Iterator<?> it = list.iterator();
while (it.hasNext()){
Object o = it.next();
System.out.println(o);
}
}
}
使用这个类：
111
222
AAA
BBB
京公网安备 11010502036488号