泛型

一、泛型语法

1.1 泛型的理解和好处

1. 看一个需求：

   1. 请编写一个程序，在 ArrayList 中，添加3个 Dog 对象
   2. Dog 对象含有 name 和 age，并输出 name 和 age（要求使用 getXxx()）

2. 先使用传统方式解决 -> 引出泛型 ```java package com.eduhsp.generic_;

import java.util.ArrayList;

@SuppressWarnings({“all”}) public class Traditional_ { public static void main(String[] args) { ArrayList list = new ArrayList(); list.add(new Dog(“大黄”,10)); list.add(new Dog(“小黑”,5)); list.add(new Dog(“小花”,8)); //假如我们的程序员，不小心，添加了一只猫 list.add(new Cat(“小白”,3)); for (Object o : list) { System.out.println(“\n狗的名字: “ + ((Dog)o).getName()); System.out.println(“狗的年龄: “ + ((Dog)o).getAge()); } } } class Dog { private String name; private int age;

public Dog(String name, int age) {
    this.name = name;
    this.age = age;
}
public String getName() {
    return name;
}
public void setName(String name) {
    this.name = name;
}
public int getAge() {
    return age;
}
public void setAge(int age) {
    this.age = age;
}

} class Cat { private String name; private int age;

public Cat(String name, int age) {
    this.name = name;
    this.age = age;
}
public String getName() {
    return name;
}
public void setName(String name) {
    this.name = name;
}
public int getAge() {
    return age;
}
public void setAge(int age) {
    this.age = age;
}

}

3. **使用传统方法的问题分析**
   1. 不能对加入到集合 ArrayList 中的数据类型进行约束（不安全）
   1. 遍历的时候，需要进行类型转换，如果集合中的数据量较大，对效率有影响
4. **泛型快速体验：用泛型解决前面的问题**
```java
package com.eduhsp.generic_;
import java.util.ArrayList;
/**
 * @author HarborGao
 * @version 1.0
 */
@SuppressWarnings({"all"})
public class Generic01 {
    public static void main(String[] args) {
        ArrayList<Dog> list = new ArrayList<Dog>();
        //解读：
        //1. 当加入了泛型约束，存放到集合中的元素被指定
        //2. 如果编译器发现添加的类型，不满足要求，就会报错
        //3. 在遍历的时候，可以直接取出 Dog 类型而不是 Object 类型
        list.add(new Dog("大黄",10));
        list.add(new Dog("小黑",5));
        list.add(new Dog("小花",8));
        //假如我们的程序员，不小心，添加了一只猫
        //list.add(new Cat("小白",3));  //会编译时报错
        for (Dog dog : list) {  //可以直接获取 Dog类型
            System.out.println(dog.getName() + " - " + dog.getAge());
        }
    }
}

1. 泛型的好处

   1. 编译时，检查添加元素的类型，提高了安全性

   2. 减少了类型转换的次数，提高效率

      不使用泛型：Dog -> Object -> Dog //放入到 ArrayList 会先转成 Object，在取出时，还需要转成Dog 使用泛型：Dog -> Dog -> Dog //放入时，和取出时，不需要类型转换，提高效率

   3. 不再提示编译警告

1.2 泛型的简单介绍

1. 泛型又称参数化类型，是 Jdk 5.0 出现的新特性，解决数据类型的安全性问题
2. 在类声明或实例化时只要指定好需要的具体的类型即可
3. Java 泛型可以保证如果程序员在编译时没有发出警告，运行时就不会产生ClassCastException异常。同时，代码更加简洁，健壮。
4. 泛型的作用是：可以在类声明时通过一个标识表示类中某个属性的类型，或者是某个方法的返回值的类型，或者是参数类型 ```java package com.eduhsp.generic_;

/**

• @author HarborGao
• @version 1.0 */

/*

• 泛型的作用是：可以在类声明时通过一个标识表示类中某个属性的类型，

• 或者是某个方法的返回值的类型，或者是参数类型 */ public class Generic02 { public static void main(String[] args) {

   //注意，特别强调：E具体的数据类型在定义Person对象的时候指定，即在编译期间，就确定了E是什么类型
   Person<String> person = new Person<>("hello");
   System.out.println(person.f());
   person.t();
   Person<Integer> person1 = new Person<>(100);
   System.out.println(person1.f());
   person1.t();

  } } class Person { E s; //E表示s的数据类型,该数据类型是在定义Person对象的时候指定,即在编译期间,就确定E是什么类型

  public Person(E s) { //E也可以是参数类型

   this.s = s;

  } public E f() { //返回类型使用E

   return s;

  } public void t() {

   System.out.println(s.getClass());

  } } ```

1.3 泛型的声明

interface 接口{} 和 class 类{}
//比如：List，ArrayList
说明：

1. 其中，T, K, V 不代表值，而是表示类型
2. 任意字母都可以。常用T表示，是Type 的缩写

1.4 泛型的实例化

要在类名后面指定类型参数的值（类型） 如：

1. List strList = new ArrayList();
2. Iterator iterator = customers.iterator();

1.5 泛型语法和使用

package com.eduhsp.generic_;
import java.util.*;
@SuppressWarnings({"all"})
public class GenericExercise {
    public static void main(String[] args) {
        HashSet<Student> students = new HashSet<Student>();
        students.add(new Student("小明",10));
        students.add(new Student("小红",12));
        students.add(new Student("小强",15));
        for (Student student : students) {
            System.out.println(student);
        }
        HashMap<String, Student> hm = new HashMap<>();
        hm.put("小明", new Student("小明",10));
        hm.put("小红", new Student("小红",12));
        hm.put("小强", new Student("小强",15));
        Set<Map.Entry<String, Student>> entries = hm.entrySet();
        Iterator<Map.Entry<String, Student>> iterator = entries.iterator();
        while (iterator.hasNext()) {
            Map.Entry<String, Student> next =  iterator.next();
            System.out.println(next.getKey() + " - " + next.getValue());
        }
    }
}

1.6 泛型使用的注意事项和细节

1. interface List{} , public class HashSet{} …等等

说明：T, E 只能是引用类型
看看下面语句是否正确？
List list = new ArrayList();
List list2 = new ArrayList();

1. 在给泛型指定具体类型后，可以传入该类型或者其子类类型

2. 泛型使用形式：

List list1 = new ArrayList();
List list2 = new ArrayList<>(); //在实际开发中，往往这样简写，编译器会自动进行类型推断
如果这样写：List list3 = new ArrayList(); 默认给它的泛型是 Object
等价于：List