目录
1、概念
Java泛型是JDK1.5中引⼊的⼀个新特性，其本质是参数化类型，把类型作为参数传递。 常⻅形式有泛型类、泛型接⼝、泛型⽅法。
2、优点
1）编译时，检查添加元素的类型，提高了安全性
2）减少了类型转换次数，提高了效率
public class Test {
public static void main(String[] args) {
ArrayList<Dog> arrayList = new ArrayList<>();
arrayList.add(new Dog("贝贝",5));
arrayList.add(new Dog("乐乐",3));
arrayList.add(new Dog("小黑",4));
//arrayList.add(new Cat("贝贝",5)); 错误
for (Dog dog : arrayList) {
System.out.println(dog.getName()+"-"+dog.getAge());
}
}
}
3、泛型使用实例
public class Test {
public static void main(String[] args) {
HashSet<Student> hashSet = new HashSet<>();
hashSet.add(new Student("张三",22));
hashSet.add(new Student("李四",23));
hashSet.add(new Student("王五",24));
//遍历
for (Student student : hashSet) {
System.out.println(student);
}
//使用泛型方式给HashMap放入三个学生对象
HashMap<String, Student> hashMap = new HashMap<>();
hashMap.put("Tom",new Student("Tom",22));
hashMap.put("Jack",new Student("Jack",23));
hashMap.put("Smith",new Student("Smith",24));
//迭代器 entrySet
Set<Map.Entry<String, Student>> entrySet = hashMap.entrySet();
Iterator<Map.Entry<String, Student>> iterator = entrySet.iterator();
System.out.println("===========================");
while (iterator.hasNext()) {
Map.Entry<String, Student> next = iterator.next();
System.out.println(next.getKey()+"-"+next.getValue());
}
}
}
4、泛型使用细节
1）interface List<T>{}，public class HashSet<E>{}...等等
T、E只能是引用类型
ArrayList<Integer> list1 = new ArrayList<>(); //正确 ArrayList<int> list2 = new ArrayList<int>(); //错误
2）在给泛型指定具体类型后，可以传入该类型或者其子类类型
public class Demo03 {
public static void main(String[] args) {
//因为E制定了A类型，构造器传入了new A
//在给泛型指定具体类型后，可以传入该类型或者其子类类型
Pig<A> pig = new Pig<A>(new A());
Pig<A> pig1 = new Pig<A>(new B());
}
}
class A{}
class B extends A{}
class Pig<E>{
E e;
public Pig(E e) {
this.e = e;
}
}
3）在实际开发中，我们往往简写
ArrayList<Integer> list = new ArrayList<Integer>(); //简写 ArrayList<Integer> list1 = new ArrayList<>();
5、自定义泛型类
注意细节：
1）普通成员可以使用泛型
public class AA<T,R> {
T t;
R r;
}
2）使用泛型的数组，不能初始化
public class AA<T,R> {
T t;
R r;
T[] ts;
//T[] ts =new T[4]; 不能初始化
}
3）静态方法中不能使用类的泛型
//因为静态时和类相关，在类加载时，对象还没创建，所以静态属性和静态方法使用了泛型，JVM就无法完成初始化
// static R r2;
// public static void m(T t){}
4）泛型类的类型是在创建对象时确定的
5）如果创建对象时没有指定类型，默认为Object
6、自定义泛型接口
注意细节：
1）接口中，静态成员也不能使用泛型
2）泛型接口的类型，在继承接口或实现接口时确定
3）没有指定类型，默认为Object
public interface IUsb<U,R> {
int n=10;
//U name; 不能这样使用，静态成员不能使用泛型
//普通方法，可以使用接口泛型
U get(U u);
void hi(R r);
void run(R r1,R r2,U u1,U u2);
//在JDK8中，可以在接口中，使用默认方法,也是可以使用泛型
default R method(U u){
return null;
}
}
public interface IA extends IUsb<String, Double> {
}
public class AA implements IA {
//当我们去实现IA接口时，因为IA在继承IUsb接口时，制定了U为String,R为Double
//在实现IUsb接口的方法时，使用String替换U，Double替换R
@Override
public String get(String s) {
return null;
}
@Override
public void hi(Double aDouble) {
}
@Override
public void run(Double r1, Double r2, String u1, String u2) {
}
}
7、自定义泛型方法
注意细节：
1）泛型方法，可以定义在普通类中，也可以定义在泛型类中
class Car{//普通类
public void run(){//普通方法
}
public<T,R> void fly(T t,R r){//泛型方法
}
}
class fish<T,R>{//泛型类
public void run(){
}
public <U,M>void eat(U u, M m){
}
}
2）当泛型方法被调用时，类型会确定
public class Test {
public static void main(String[] args) {
Car car = new Car();
//当调用方法时，传入参数，编译器就会确定类型
car.fly("宝马",100);
}
}
3） public void swim(T t){}不是泛型方法，而是使用了类声明的泛型。
本文含有隐藏内容，请 开通VIP 后查看