Java | 韩顺平 循序渐进学Java自用笔记---OOP高级（二）
十四、泛型
14.1、引入泛型
案例：
1）不能对加入到集合 ArrayList中的数据类型进行约束(不安全)
2）遍历的时候，需要进行类型转换，如果集合中的数据量较大，对效率有影响
14.2、泛型的理解和好处
泛型的好处
1）编译时，检查添加元素的类型，提高了安全性
2）减少了类型转换的次数，提高效率
∨ 不使用泛型
Dog - 加入->0bject -取出->Dog
//放入到ArrayList 会先转成 Object，在取出时，还需要转换成Dog
∨ 使用泛型Dog -> Dog -> Dog
// 放入时，和取出时，不需要类型转换，提高效率
3）不再提示编译警告
14.3、泛型介绍
int a = 10;
理解：泛(广泛)型(类型)=>Integer, String,Dog
1）泛型又称参数化类型，是Jdk5.0 出现的新特性，解决数据类型的安全性问题
2）在类声明或实例化时只要指定好需要的具体的类型即可
3）Java泛型可以保证如果程序在编译时没有发出警告，运行时就不会产生ClassCastException异常。同时，代码更加简洁、健壮
4）泛型的作用是：可以在类声明时通过一个标识表示类中某个属性的类型或者是某个方法的返回值的类型，或者是参数类型
14.4、泛型语法
14.4.1 泛型的声明
interface 接囗<T>{} 和 class 类<K,V>{} 比如: List ， ArrayList
说明:
1）其中，T,K,V不代表值，而是表示类型
2）任意字母都可以。常用T表示，是Type的缩写
14.4.2 泛型的实例化
要在类名后面指定类型参数的值(类型)。
如:
1）List<String> strList = new ArrayList<String>();[
2）lterator<Customer>iterator = customers.iterator();
14.4.3 泛型使用举例
举例说明，泛型在 HashSet,HashMap 的使用情况
练习：创建 3个学生对象放入到HashSet中学生对象使用。放入到 HashMap中，要求Key是String name, Value就是 学生对象使用两种方式遍历
@SuppressWarnings({"all"})
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 个学生对象//K -> String V->StudentHashMap<String, Student> hm = new HashMap<String, Student>();/*public class HashMap<K,V> {}*/hm.put("milan", new Student("milan", 38));hm.put("smith", new Student("smith", 48));hm.put("hsp", new Student("hsp", 28));//迭代器 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();/*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;}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;}@Overridepublic String toString() {return "Student{" +"name='" + name + '\'' +", age=" + age +'}';}
}
14.4.4 泛型使用的注意事项和细节
1、interface List<T>{} ,public class HashSet<E>{}.. 等等
说明：T,E只能是引用类型
看看下面语句是否正确?
List<Integer> list = new ArrayList<Integer>();//OK
List<int>list2 = new ArrayList<int>();//错误
2、在给泛型指定具体类型后，可以传入该类型或者其子类类型
//因为 E 指定了 A 类型, 构造器传入了 new A()
3、泛型使用形式
ArrayList<Integer> list1 = new ArrayList<Integer>();
List<Integer> list2 = new ArrayList<Integer>();
//在实际开发中，我们往往简写
//编译器会进行类型推断, 老师推荐使用下面写法
ArrayList<Integer> list3 = new ArrayList<>();
List<Integer> list4 = new ArrayList<>();
ArrayList<Pig> pigs = new ArrayList<>();
如果我们这样写 List list3 = new ArrayList();
默认给它的 泛型是 <E> E就是 Object
ArrayList arrayList = new ArrayList();
//等价 ArrayList<Object> arrayList = new ArrayList<Object>();
14.5、练习
* 传入 Comparator 对象[使用泛型]，先按照 name 排序，如果 name 相同，则按生日日期的先后排序。【即：定制排序】
0559_韩顺平Java_泛型课堂练习_哔哩哔哩_bilibili
@SuppressWarnings({"all"})
public class GenericExercise02 {public static void main(String[] args) {ArrayList<Employee> employees = new ArrayList<>();employees.add(new Employee("tom", 20000, new MyDate(1980,12,11)));employees.add(new Employee("jack", 12000, new MyDate(2001,12,12)));employees.add(new Employee("tom", 50000, new MyDate(1980,12,10)));System.out.println("employees=" + employees);employees.sort(new Comparator<Employee>() {@Overridepublic int compare(Employee emp1, Employee emp2) {//先按照 name 排序，如果 name 相同，则按生日日期的先后排序。【即：定制排序】//先对传入的参数进行验证if(!(emp1 instanceof Employee && emp2 instanceof Employee)) {System.out.println("类型不正确..");return 0;}//比较 nameint i = emp1.getName().compareTo(emp2.getName());if(i != 0) {return i;}//下面是对 birthday 的比较，因此，我们最好把这个比较，放在 MyDate 类完成//封装后，将来可维护性和复用性，就大大增强. return emp1.getBirthday().compareTo(emp2.getBirthday());}});System.out.println("==对雇员进行排序==");System.out.println(employees);}
}14.6、自定义泛型
14.6.1、自定义泛型类
基本语法
class 类名<T, R...>{//...表示可以有多个泛型
成员
}
注意细节
1）普通成员可以使用泛型(属性、方法)
2）使用泛型的数组，不能初始化
T[] ts =new T[8]; 错误
因为数组在new不能确定T的类型，就无法在内存开辟空间
3）静态方法中不能使用类的泛型
//因为静态是和类相关的，在类加载时，对象还没有创建
//所以，如果静态方法和静态属性使用了泛型，JVM 就无法完成初始化
4）泛型类的类型，是在创建对象时确定的(因为创建对象时，需要指定确定类型)
5）如果在创建对象时，没有指定类型，默认为Object
class Tiger<T, R, M> {
String name;
R r;
M m;
Tt;
}
@SuppressWarnings({"all"})
public class CustomGeneric_ {public static void main(String[] args) {//T=Double, R=String, M=IntegerTiger<Double,String,Integer> g = new Tiger<>("john");g.setT(10.9); //OK//g.setT("yy"); //错误，类型不对System.out.println(g);Tiger g2 = new Tiger("john~~");//OK T=Object R=Object M=Objectg2.setT("yy"); //OK ,因为 T=Object "yy"=String 是 Object 子类System.out.println("g2=" + g2);}
}//1. Tiger 后面泛型，所以我们把 Tiger 就称为自定义泛型类
//2, T, R, M 泛型的标识符, 一般是单个大写字母
//3. 泛型标识符可以有多个. //4. 普通成员可以使用泛型 (属性、方法)
//5. 使用泛型的数组，不能初始化 T[] ts =new T[8];
//6. 静态方法中不能使用类的泛型
class Tiger<T, R, M> {String name;R r; //属性使用到泛型M m;T t;//因为数组在 new 不能确定 T 的类型，就无法在内存开空间T[] ts;public Tiger(String name) {this.name = name;}public Tiger(R r, M m, T t) {//构造器使用泛型this.r = r;this.m = m;this.t = t;}public Tiger(String name, R r, M m, T t) {//构造器使用泛型this.name = name;this.r = r;this.m = m;this.t = t;}
//因为静态是和类相关的，在类加载时，对象还没有创建
//所以，如果静态方法和静态属性使用了泛型，JVM 就无法完成初始化
// static R r2;
// public static void m1(M m) {//
// }
//方法使用泛型public String getName() {return name;}public void setName(String name) {this.name = name;}public R getR() {return r;}public void setR(R r) {//方法使用到泛型this.r = r;}public M getM() {//返回类型可以使用泛型. return m;}public void setM(M m) {this.m = m;}public T getT() {return t;}public void setT(T t) {this.t = t;}@Overridepublic String toString() {return "Tiger{" +"name='" + name + '\'' +", r=" + r +", m=" + m +", t=" + t +", ts=" + Arrays.toString(ts) +'}';}
}判断
14.6.2、自定义泛型接口
基本语法
interface 接囗名<T, R...>{
注意细节
1）接口中，静态成员也不能使用泛型(这个和泛型类规定一样)
2）泛型接口的类型，在继承接口或者实现接口时确定
3）没有指定类型，默认为Object