1、泛型
作用于编译时用于对象类型检查，运行时不起作用。
泛型的声明在一对尖角括号中 <>，泛型名称可以是任意字母。
2、泛型类
用于类中，在类名末尾对泛型进行声明；
在对该类进行实例化时，需要将泛型指定为具体的包装类，此时，在实例化泛型类时，就可以起到编译时检查的作用。
代码语言：javascript复制public class TestGeneric<M> {
private M t;
public TestGeneric(M t){
this.t = t;
}
public M getT() {
return t;
}
public void setT(M t) {
this.t = t;
}
public static void main(String[] args) {
TestGeneric<Integer> generic = new TestGeneric<>(12);
generic.setT(251);
System.out.println(generic.getT());
}
}3、泛型接口
用于接口中，在接口名末尾对泛型进行声明；
代码语言：javascript复制public interface GenericInterface<T> {
T getName(T t);
}当对该接口创建实现类时，有两种方式
3.1、实现类中对接口的泛型指定具体包装类
代码语言：javascript复制class GenericImpl implements GenericInterface<String>{
@Override
public String getName(String s) {
return s;
}
public static void main(String[] args) {
GenericInterface<String> generic = new GenericImpl();
String sss = generic.getName("sss");
}
}3.2、实现类中依然使用泛型
在实现类中依然使用泛型，但需要在实现类名的后边，对泛型进行重新声明
代码语言：javascript复制class GenericImpl2<T> implements GenericInterface<T>{
@Override
public T getName(T t) {
return t;
}
public static void main(String[] args) {
GenericInterface<Integer> g2 = new GenericImpl2<>();
Integer name = g2.getName(12);
System.out.println(name);
}
}4、泛型方法
无论是静态方法还是普通方法，在方法声明中，都必须对泛型进行声明；
代码语言：javascript复制public class GenericMethod {
//无返回值
public <T> void getName(T t){
System.out.println(t);
}
//有返回值
public <T> T getAge(T t){
return t;
}
//静态方法，泛型需要在方法声明中定义
public static <T> void getUser(T t){
System.out.println("static");
}
public static void main(String[] args) {
GenericMethod gm = new GenericMethod();
gm.getName("张三");
Integer age = gm.getAge(123);
System.out.println(age);
getUser('A');
}
}5、泛型通配
当对泛型类型不确定时，也可以使用 <?> 声明为类型可变的泛型，以增加泛型的灵活适配。
代码语言：javascript复制public class NormalGeneric {
//泛型中的通配符
public void showMsg(TestGeneric<?> generic){
System.out.println(generic.getT());
}
public static void main(String[] args) {
NormalGeneric normalGeneric = new NormalGeneric();
TestGeneric<Integer> g1 = new TestGeneric<>(123);
normalGeneric.showMsg(g1);
TestGeneric<String> g2 = new TestGeneric<>("abc");
normalGeneric.showMsg(g2);
}
}6、泛型方法中的可变参数
当泛型方法中的参数不固定时，也可以使用可变参数的写法，来定义泛型方法。
代码语言：javascript复制public class NormalGeneric {
//泛型方法中的可变参数
public <T> void showMsg(T ... args){
for (T t : args) {
System.out.println(t);
}
}
public static void main(String[] args) {
NormalGeneric normalGeneric = new NormalGeneric();
normalGeneric.showMsg("hello", "world", "java");
normalGeneric.showMsg(1, 3, 5);
}
}7、泛型对象限制
上限限定：使用 泛型通配符 ? extends 关键字，指明该泛型只能使用约定类型及其子类型；
下限限定：使用 泛型通配符 ? super 关键字，指明该泛型只能使用约定类型及其父类型。
代码语言：javascript复制public class NormalLimit {
//泛型类型，通配符的上限限定，只能使用约定类型及其子类型
public void highLimit(TestGeneric<? extends Number> number){
System.out.println(number);
}
//泛型类型，通配符的下限限定，只能使用约定类型及其父类型
public void lowLimit(TestGeneric<? super Number> number){
System.out.println(number);
}
public static void main(String[] args) {
NormalLimit n = new NormalLimit();
TestGeneric<Integer> t = new TestGeneric<>(123);
TestGeneric<Number> t2 = new TestGeneric<>(123);
TestGeneric<Object> t3 = new TestGeneric<>("abc");
n.highLimit(t2);
n.highLimit(t);
//n.highLimit(t3); //上限限定，不能使用父类型
//n.lowLimit(t); //下限限定，不能使用子类型
n.lowLimit(t2);
n.lowLimit(t3);
}
}
