15泛型
1. 泛型的引入
1.1 泛型的好处
@SuppressWarnings({"all"})
public class Dog01 {
public static void main(String[] args) {
ArrayList list = new ArrayList();
list.add(new Dog("jack", 12));
list.add(new Dog("tom", 11));
list.add(new Dog("mary", 5));
list.add(new Cat("lucy", 3));//1.由于Cat类的不小心加入，在(Dog)向下转型时就会抛出异常
for (int i = 0; i < list.size(); i++) {
System.out.println(((Dog)list.get(i)).age);//对Cat类抛出ClassCastException类转换异常
System.out.println(((Dog)list.get(i)).name);//2.数据太大时每次都要向下转型导致效率不高
}
}
}
class Dog{
public String name;
public int age;
public Dog(String name, int age) {
this.name = name;
this.age = age;
}
}
class Cat{
private String name;
private int age;
public Cat(String name, int age) {
this.name = name;
this.age = age;
}
}
传统方法的问题：
- 不能对加入到集合 ArrayList 中的数据类型进行约束(不安全，比如上面的不小心加入Cat类)
- 遍历的时候，需要进行类型转换（比如Dog类的向下转型），如果集合中的数据量较大，对效率有影响
泛型解决上述问题：
@SuppressWarnings({"all"})
public class Generic01 {
public static void main(String[] args) {
//1.当用ArrayList<Dog>方式，表示存放到ArrayList集合中的元素只能是Dog类型
//2.如果编译器发现添加的类型，不满足Dog类要求时，就会报错
//3.在遍历的时候，可以直接取出Dog类型，而不是Object类型（向下转型可以省略了）
ArrayList<Dog> list = new ArrayList<Dog>();
list.add(new Dog("jack", 12));
list.add(new Dog("tom", 11));
list.add(new Dog("mary", 5));
//不小心加了一个猫
//list.add(new Cat("lucy", 3));//1.报错
for (Dog dog : list) {
System.out.print(dog.age + "-");//2.不需要向下转型了
System.out.println(dog.name);
}
}
}
class Dog{
public String name;
public int age;
public Dog(String name, int age) {
this.name = name;
this.age = age;
}
}
class Cat{
private String name;
private int age;
public Cat(String name, int age) {
this.name = name;
this.age = age;
}
}
1.2 基本介绍
老韩理解：泛（广泛）型（类型）=> 可以是 Integer，String，Dog（自定义类型）
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable
//上面是ArrayList类的定义，那个<E>就表示泛型，1.1代码中我们用的ArrayList<Dog>就相当于把Dog类型指定给了E，所以在ArrayList对象中涉及到E的都用Dog类型的对象来替换
-
泛型又称参数化类型，是 Jdk5.0 出现的新特性，解决数据类型的安全性问题
-
在类声明或实例化时只要指定好需要的具体的类型即可。
-
Java 泛型可以保证如果程序在编译时没有发出警告，运行时就不会产生ClassCastException 异常。同时，代码更加简洁、健壮
-
泛型的作用是：可以在类声明时通过一个**标识**表示类中某个属性的类型，或者是某个方法的返回值的类型，或者是参数类型。举例如下：
public class Generic01 {
public static void main(String[] args) {
//注意：E具体的数据类型在定义Person对象的时候指定，即在编译期间，就确定E是什么类型了
Person<String> person = new Person<>("丁帅");
//相当于对象person的所有E都用String替换
person.show();//String
}
}
//通过标识<E>来表示Person类中的s属性，创建Person类对象时指定E的类型，即指定了属性s的类型。方法也可以用这个原理
class Person<E>{
E s;//用E表示s的数据类型，
public Person(E s){//E也可以是参数类型
this.s = s;
}
public E f(){//返回类型使用E
return s;
}
public void show(){
System.out.println(s.getClass());
}
}
2. 泛型的语法
2.1 泛型的声明
2.2 泛型的实例化
/*
举例说明，泛型在 HashSet, HashMap 的使用情况
1.创建3个学生对象
2.放入到HashSet中学生对象
3.放入到HashMap中，要求 Key 是 String name, Value就是学生对象
4.使用两种方式遍历
*/
public class GenericExercise {
public static void main(String[] args) {
//使用泛型方式给 HashSet 放入 3 个学生对象
HashSet<Student> students = new HashSet<Student>();
students.add(new Student("jack", 18));
students.add(new Student("tom", 28));
students.add(new Student("mary", 19));
//遍历
for (Student student : students) {
System.out.println(student);
}
//使用泛型方式给 HashMap 放入 3 个学生对象
//HashMap类的定义： public class HashMap<K,V> {}
//K -> String V->Student
HashMap<String, Student> hm = new HashMap<String, Student>();
hm.put("milan", new Student("milan", 38));
hm.put("smith", new Student("smith", 48));
hm.put("hsp", new Student("hsp", 28));
//迭代器 EntrySet
/* entrySet()方法的定义：
public Set<Map.Entry<K,V>> entrySet() {
Set<Map.Entry<K,V>> es;
return (es = entrySet) == null ? (entrySet = new EntrySet()) : es;
}
*/
Set<Map.Entry<String, Student>> entries = hm.entrySet();
/* 迭代器，iterator()方法的定义：
public final Iterator<Map.Entry<K,V>> iterator() {
return new EntryIterator();
}
*/
Iterator<Map.Entry<String, Student>> iterator = entries.iterator();
System.out.println("==============================");
while (iterator.hasNext()) {
Map.Entry<String, Student> next = iterator.next();
System.out.println(next.getKey() + "-" + next.getValue());
}
}
}
class Student{
private String name;
private int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
2.3 使用细节
- 给泛型指定数据类型必须是引用类型，不能是基本数据类型（int 什么的）
List<Integer> list = new ArrayList<lnteger>();//OK
List<int> list2 = new ArrayList<int>();//错误，泛型不能是基本数据类型，必须是引用数据类型
-
在给泛型指定具体类型后，可以传入该类型或者其子类类型
@SuppressWarnings({"all"}) public class Generic01 { public static void main(String[] args) { //因为 E 指定了 A 类型，构造器传入了 new A() Pig<A> aPig = new Pig<A>(new A());//可以传入A，也可以传入A的子类型 Pig<A> aPig1 = new Pig<A>(new B());//如果B类没有extends A类，这一句就报错 aPig.show();//A aPig1.show();//B } } class A{} class B extends A{} class Pig<E>{ E e; public Pig(E e) { this.e = e; } public void show(){ System.out.println(e.getClass()); } } -
泛型使用形式：
List<Integer> list1 = new ArrayList<Integer>(); //下面这一句是上面的简写，实际开发中往往简写，也推荐下面这种简写方式。 //等号右边的ArrayList<>会进行自动类型推断ArrayList<Integer> List<Integer> list2 = new ArrayList<>(); List list3 = new ArrayList();//默认给它的泛型是[<E> E就是Object]
3. 自定义泛型
3.1 自定义泛型类
基本语法：
class 类名/接口名 <T,R...>{
成员
}
@SuppressWarnings({"all"})
public class Generic01 {
public static void main(String[] args) {
}
}
//1.Tiger 后面就是泛型，所以我们把Tiger就称为自定义泛型类
//2.T，R，M 泛型的标识符，一般是单个大写字母
//3.泛型标识符可以有多个
//4.普通成员可以使用泛型（属性、方法）
//5.使用泛型的数组，不能初始化
//6.静态成员不能使用泛型
class Tiger<T, R, M>{
String name;
R r; //属性使用泛型4
M m;
T t;
//报错，因为数组在new的时候不能确定T的类型，就无法在内存开辟空间。可以定义，但是不能初始化5
T[] ts = new T[8];
//因为静态是和类相关的，在类加载时，对象还没有创建，而泛型的确定是在初始化对象的时候6
//所以，如果 静态方法 或者 静态属性 使用了泛型，那么JVM就无法完成初始化（JVM不知道R是什么类型）6
static R r2;//报错
public static void m1(M m){//报错
}
public Tiger(String name, R r, M m, T t) {//构造器使用泛型4
this.name = name;
this.r = r;
this.m = m;
this.t = t;
}
public R getR() {//方法使用泛型4
return r;
}
public void setR(R r) {
this.r = r;
}
}
//判断下面语句正确性
Tiger<Double,String,Integer> g = new Tiger<>("john"); //T=Double, R=String, M=Integer
g.setT(10.9); // ok
g.setT("yy"); // 报错，类型不匹配
System.out.println(g);
Tiger g2 = new Tiger("john~~");// T=Object R=Object M=Object
g2.setT("yy"); // ok，因为 T=Object "yy"=String 是 Object 子类
System.out.println("g2=" + g2);
class Tiger<T, R, M>{
String name;
R r;
M m;
T t;
public Tiger(String name) {
this.name = name;
}
public void setT(T t) {
this.T = t;
}
}
3.2 自定义泛型接口
基本语法：
interface 接口名 <T.R...>{
}
/**
* 1.接口中，静态成员也不能使用泛型
* 2.泛型接口的类型，在 继承接口或者实现接口时确定
* 3.
*/
//在继承接口时，指定泛型接口的类型2
interface IA extends IUsb<String, Double>{
}
//当我们实现IA接口时，因为IA在继承IUsb接口时，指定了U为String，R为Double
//因此在实现IUsu接口的方法时，使用String替换U，使用Double替换R
class AA implements IA{
@Override
public Double get(String s) {
return null;
}
@Override
public void hi(Double aDouble) {
}
//接口IUsb中提供的默认方法，可以重写也可以不重写
@Override
public Double method(String s) {
return null;
}
}
//不推荐class BB implements IUsb，推荐class BB implements IUsb<Object, Object>
class BB implements IUsb<Object, Object>{
@Override
public Object get(Object o) {
return null;
}
@Override
public void hi(Object o) {
}
}
interface IUsb<U, R>{
//普通方法中，可以使用接口泛型
int n = 10;
//不对，因为接口中的属性都是 public static final的，只是这三个关键字可以省略
//U name; //U的类型不确定，所以这个静态属性name的类型就不确定1
R get(U u);
void hi(R r);
//在jdk8中，可以在接口中，使用默认方法，也是可以使用泛型
default R method(U u) {
return null;
}
}
3.3 自定义泛型方法
基本语法：
修饰符 <T,R...> 返回类型 方法名(参数列表){
}
注意细节：
-
泛型方法，可以定义在普通类中，也可以定义在泛型类中
-
当泛型方法被调用时，类型会确定
-
public void eat(E e){} ，修饰符后没有 <T,R…> ，因此 eat 方法不是泛型方法，而是使用了泛型
@SuppressWarnings({"all"})
public class Generic01 {
public static void main(String[] args) {
Car car = new Car();
//第2条：当调用方法时，传入参数，编译器就会确定相应的类型。
car.fly("宝马", 100); //T String，R Integer
car.fly(12.2, 100); //T Double，R Integer
}
}
//第1条：
class Car{//普通类
//泛型方法fly。<T, R>就是泛型，是提供给fly使用的
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){//泛型方法
}
//第3条：下面hi方法不是泛型方法，而是hi方法使用了类声明的泛型
public void hi(T t){
}
//方法可以使用自己定义的泛型，也可以使用类定义的泛型
public <K> void hello(R r, K k){
}
}
4. 泛型的继承和通配符
- 泛型不具备继承性
Object o = new String("xx"); //可以的
List<Object> list = new ArrayList<String>(); //不对
- <?>：支持任意泛型类型
- <? extends A>：支持A类以及A类的子类，规定了泛型的上限
- <? super A>：支持A类以及A类的父类，不限于直接父类，规定了泛型的下限
public class GenericExtends {
public static void main(String[] args) {
Object o = new String("xx");
//泛型没有继承性
//List<Object> list = new ArrayList<String>();
//举例说明下面三个方法的使用
List<Object> list1 = new ArrayList<>();
List<String> list2 = new ArrayList<>();
List<AA> list3 = new ArrayList<>(); //list3 里面可以传入 AA 类型或者 AA 的子类型
List<BB> list4 = new ArrayList<>();
List<CC> list5 = new ArrayList<>();
//如果是 List<?> c ，可以接受任意的泛型类型
printCollection1(list1);
printCollection1(list2);
printCollection1(list3);
printCollection1(list4);
printCollection1(list5);
//List<? extends AA> c： 表示 上限，可以接受 AA 或者 AA 子类
// printCollection2(list1);//×
// printCollection2(list2);//×
printCollection2(list3);//√
printCollection2(list4);//√
printCollection2(list5);//√
//List<? super AA> c: 支持 AA 类以及 AA 类的父类，不限于直接父类
printCollection3(list1);//√
//printCollection3(list2);//×
printCollection3(list3);//√
//printCollection3(list4);//×
//printCollection3(list5);//×
}
//说明: List<?> 表示 任意的泛型类型都可以接受。我的理解：传入一个List这个List里面的数据类型可以是任意的
public static void printCollection1(List<?> c) {
for (Object object : c) {// 通配符，取出时，就是 Object
System.out.println(object);
}
}
// ? extends AA 表示上限，可以接受 AA 或者 AA 子类。
//我的理解：传入一个List，这个List在定义时List<T,R...>里面的指定的数据类型T,R...必须是AA类或者AA类的子类
public static void printCollection2(List<? extends AA> c) {
for (Object object : c) {
System.out.println(object);
}
}
// ? super 子类类名 AA:支持 AA 类以及 AA 类的父类，不限于直接父类， 规定了泛型的下限
//我的理解：传入一个List，这个List在定义时List<T,R...>里面的指定的数据类型T,R...必须是AA类或者AA类的父类
public static void printCollection3(List<? super AA> c) {
for (Object object : c) {
System.out.println(object);
}
}
}
class AA {}
class BB extends AA {}
class CC extends BB { }
7万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
