为什么使用泛型

泛型的字面意思就是广泛的类型。利用泛型，同一套代码可以用于多种数据类型， 这样，不仅可以复用代码，降低耦合，而且可以提高代码的可读性和安全性

可读性：var s=new ArrayList<String>();

安全性：

（1）编译器可以检查，防止插入错误类型的对象。即把运行时出现的强制类型转换异常提前到编译器异常。

ArrayList<String>list=new ArrayList<>();
list.add("abc");
list.add(1);//报错
  • 1.
  • 2.
  • 3.

（2）ArrayList内部如果不使用类型参数，而使用Object数组，那么当获取一个值时必须进行强制类型转换。当使用向下转型并且对象数据类型不同时会出错。

安全性（2）代码

//缺省默认为Object类型
ArrayList list=new ArrayList();
list.add("a");
list.add(1);

Iterator it=list.iterator();
while(it.hasNext()){
  Object obj=it.next();
  如果想要使用对象的方法,必须使用强制类型转换.
}
//坏处：不能调用对象的方法（向上转型），当使用向下转型并且对象数据类型不同时会出错
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.

学习泛型的用处：排除代码的问题，读懂集合类内部工作原理


【java笔记】泛型定义和使用_java

 String作为参数赋值给E

定义泛型类：修饰符 class 类名<类型变量>

类型遍历：在类定义中用于指定方法的返回类型以及字段和局部变量的类型

<T>,<T,U,....>

可以用具体的类型变量来实例化泛型类型

可以说，泛型类相当于普通类的工厂

public class fanxing <E>{
    private E name;
    public fanxing() {
    }
    public fanxing(E name) {
        this.name = name;
    }
    public E getName() {
        return name;
    }
    public void setName(E name) {
        this.name = name;
    }
}

public class Demp {
    public static void main(String[] args) {
       fanxing<String>f1=new fanxing<>();
       f1.setName("a");
        System.out.println(f1.getName());
        fanxing<Integer>f2=new fanxing<>();
        f2.setName(1);
        System.out.println(f2.getName());

    }
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.
  • 22.
  • 23.
  • 24.
  • 25.
  • 26.

 创建集合对象的时候，会确定泛型的数据类型

定义和使用含有泛型的方法：

修饰符<代表泛型的变量>返回值类型 方法名（参数）{}

public class fanxing{
   //定义含有一个泛型的方法
    public<M>void method(M m){
        System.out.println(m);
    }
}
public class Demp {
    public static void main(String[] args) {
fanxing f1=new fanxing();
f1.method("asd");
f1.method(1);
f1.method(1.2);
f1.method(true);
    }
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.

定义含有泛型的静态方法

静态方法通过类直接调用

public class fanxing{
   //定义含有一个泛型的方法
   public static <M>void method(M m){
        System.out.println(m);
    }
}
public class Demp {
    public static void main(String[] args) {
 fanxing.method("1234");
    }
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.

定义含有泛型的接口

一.接口的实现类确定泛型的类型
public interface fanxing<I>{
   void method(I i);
}
public class faxingimp implements fanxing<String>{
    @Override
    public void method(String s) {
        System.out.println(s);
    }
}
public class Demp {
    public static void main(String[] args) {
faxingimp f1=new faxingimp();
f1.method("ss");
    }
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
二.接口的实现类使用和抽象类一样的泛型，在创建实现类对象时确定数据类型
public interface fanxing<I>{
   void method(I i);
}
public class faxingimp<I> implements fanxing<I>{
    @Override
    public void method(I i) {
        System.out.println(i);
    }
}
public class Demp {
    public static void main(String[] args) {
faxingimp f1=new faxingimp();
f1.method("ss");
f1.method(1);

    }
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.

泛型通配符

?代表任意的数据类型

使用：不能创建对象使用，只能作为方法的参数使用

例：定义一个方法能遍历所有类型的Arraylist集合

public static void printArray(ArrayList<?>list){
  //使用迭代器遍历
  Iterator<?>it=list.iterator();
  while(it.hasNext()){
     Object o=it.next();
     Sout(o);   
  }
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.

（要求能看到源码即可）

泛型的上限限定：

？extends E代表使用的泛型只能是E类型的子类/本身

泛型的下限限定：

? super   E代表使用的泛型只能是E类型父类/本身

【java笔记】泛型定义和使用_后端_02