一.定义和使用含有泛型的类
/*
说明:泛型是一个未知的数据类型,当我们不确定使用什么数据类型的时候,可以使用泛型;
简单来说,就是在定义类或类的成员变量的类型的时候不把类型写死了。在创建对象的时候,想用啥类型就创建啥类型的对象。
*/
public class Person<E>{
private E userName;
private E age;
public E getUserName() {
return userName;
}
public void setUserName(E userName) {
this.userName = userName;
}
public E getAge() {
return age;
}
public void setAge(E age) {
this.age = age;
}
}
public class TestPerson {
public static void main(String[] args) {
//1.不写泛型默认为object类型
Person person = new Person();
person.setAge(18);
Object age = person.getAge();
System.out.println(age);
//2.创建Person对象,泛型使用String类型
Person<String> stringPerson = new Person<>();
stringPerson.setAge("18");//不使用String类型的数据直接编译报错
String age1 = stringPerson.getAge();
System.out.println(age1);
}
}
二.定义和使用含有泛型的方法
public class Method{
//含有泛型的普通方法
public <E> void sout1(E e){
System.out.println(e);
}
//含有泛型的静态方法
public static <E> void sout2(E e){
System.out.println(e);
}
}
public class TestMethod {
public static void main(String[] args) {
Method method = new Method();
/*
传递什么类型,泛型就是什么类型
*/
method.sout1("abc");
method.sout1(123);
method.sout1(false);
//类名调用静态方法
Method.sout2("abc");
Method.sout2(123);
}
}
三.定义和使用含有泛型的接口
方式一:
public interface Inter<E> {
public abstract void method(E e);
}
/*
实现接口时传入泛型。
*/
public class InterImpl implements Inter<String>{
/*
这里必须为String类型的参数,要和泛型定义的一致。
*/
@Override
public void method(String s) {
System.out.println(s);
}
}
public class TestInter {
public static void main(String[] args){
InterImpl inter = new InterImpl();
inter.method("abc");
}
}
方式二:
public interface Inter<E> {
public abstract void method(E e);
}
public class InterImpl<I> implements Inter<I>{
@Override
public void method(I i) {
System.out.println(i);
}
}
public class TestInter {
public static void main(String[] args){
/*
创建对象时传入泛型。
*/
InterImpl<String> stringInter = new InterImpl<>();
stringInter.method("abc");//必须传入String类型的参数,和泛型保持一致
}
}
四.泛型通配符<?>的使用
import java.util.ArrayList;
import java.util.Iterator;
public class Test {
/*
说明:<?>中的?代表任意的数据类型;
注意:不能创建对象时使用,只能作为方法的参数使用。
*/
public static void main(String[] args) {
ArrayList<Integer> list01 = new ArrayList<>();
list01.add(11);
list01.add(22);
ArrayList<String> list02 = new ArrayList<>();
list02.add("a");
list02.add("b");
/*
同一个方法传递不同类型的参数
*/
printList(list01);
printList(list02);
}
/*
参数要传递Integer和String两种类型,所以必须使用通配符,不然报错。
*/
public static void printList(ArrayList<?> list){
Iterator<?> iterator = list.iterator();
while (iterator.hasNext()){
Object next = iterator.next();//只有Object类型才能同时接收不同的类型
System.out.println(next);
}
}
}
五.泛型的上限限定和下限限定
import java.util.ArrayList;
import java.util.Collection;
public class Test {
/*
泛型的上限限定:? extends E 代表使用的泛型只能是E类型的子类/本身;
泛型的下限限定: ? super E 代表使用的泛型只能是E类型的父类/本身。
*/
public static void main(String[] args) {
ArrayList<Integer> list1 = new ArrayList<>();
ArrayList<String> list2 = new ArrayList<>();
ArrayList<Number> list3 = new ArrayList<>();
ArrayList<Object> list4 = new ArrayList<>();
getE1(list1);
getE1(list2);//因为不符合参数类型(编译报错)
getE1(list3);
getE1(list4);//因为不符合参数类型(编译报错)
getE2(list1);//因为不符合参数类型(编译报错)
getE2(list2);//因为不符合参数类型(编译报错)
getE2(list3);
getE2(list4);
}
/*
说明:Integer extends Number extends Object;
String extends Object
*/
public static void getE1(Collection<? extends Number> collection){
}
public static void getE2(Collection<? super Number> collection){
}
}