泛型
泛型介绍
(1) 泛型又称参数化类型（接收数据类型的数据类型），是Jdk5.0出现的新特性,解决数据类型的安全性问题
(2) 在类声明或实例化时只要指定好需要的具体的类型即可
(3) Java泛型可以保证如果程序在编译时没有发出警告，运行时就不会产生ClassCastException异常。同时，代码更加简洁、健壮
(4) 泛型的作用是：可以在类声明时通过一个标识表示类中某个属性的类型，或者是某个方法的返回值的类型，或者是参数类型
package testGeneric;
public class Test1 {
public static void main(String[] args) {
Person<String> person1 = new Person<>("A");
person1.show();//class java.lang.String
//此处相当于创建了该类的对象
// class Person<String> {
// String s;
//
// public Person(String s) {
// this.s = s;
// }
//
// public String getS() {
// return s;
// }
// }
Person<Integer> person2 = new Person<>(1);
person2.show();//class java.lang.Integer
//此处相当于创建了该类的对象
// class Person<Integer> {
// Integer s;
//
// public Person(Integer s) {
// this.s = s;
// }
//
// public Integer getS() {
// return s;
// }
// }
}
}
class Person<E> {
E s; //E表示s的数据类型，
// 该数据类型在定义Person对象的时候指定，即在编译期间，就确定E是什么类型
public Person(E s) {
this.s = s;
}
public E getS() {
return s;
}
public void show(){
System.out.println(s.getClass());
}
}
泛型语法
interface 接口 <T>{}
class 类 <K,V>{}
/*
在类名后指定类型参数的值(类型):
List<String> strList = new ArrayList<String>();
lterator<Customer> iterator = customers.iterator();
*/
例子:
package testGeneric;
import java.util.*;
@SuppressWarnings({"all"})
public class Test2 {
public static void main(String[] args) {
//创建Student对象
Student[] students = new Student[3];
students[0] = new Student("A",10);
students[1] = new Student("B",20);
students[2] = new Student("C",32);
//Set
HashSet<Student> set = new HashSet<Student>();
set.addAll(Arrays.asList(students));
//循环遍历
Iterator<Student> iterator = set.iterator();
while (iterator.hasNext()) {
Student next = iterator.next();
System.out.println(next);
}
//map
HashMap<String,Student> map = new HashMap<String,Student>();
for(int i = 0;i< students.length;i++){
map.put(students[i].getName(),students[i]);
}
//循环遍历
Set entryset = map.entrySet();
Iterator<Map.Entry> iterator_entry = entryset.iterator();
while (iterator_entry.hasNext()) {
Map.Entry next = iterator_entry.next();
System.out.println(next.getKey() + " " + next.getValue());
}
}
}
/**
*1.创建3个学生对象
*2.放入到HashSet中学生对象，使用.
*3.放入到HashMap中，要求Key 是String name,Value 就是学生对象
* 4.使用两种方式遍历
*/
class Student {
private String name;
private int age;
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
return age == student.age && Objects.equals(name, student.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", 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;
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
}
注意事项和细节
(1) 泛型只能是引用类型
(2) 在给泛型指定具体类型后，可以传入该类型或者其子类类型
(3) List list3 = new ArrayList()：默认给它的 泛型是[<E＞ E就是 Object]
例子
package testGeneric.homework;
import java.util.ArrayList;
import java.util.Comparator;
public class Test1 {
public static void main(String[] args) {
ArrayList<Employee> employeelist = new ArrayList<>();
employeelist.add(new Employee("AAA", 2300, new MyDate(1992, 11, 2)));
employeelist.add(new Employee("AAA", 3438, new MyDate(1987, 8, 2)));
employeelist.add(new Employee("AAA", 1232, new MyDate(2000, 2, 1)));
employeelist.sort(new Comparator<Employee>() {
@Override
public int compare(Employee o1, Employee o2) {
String name1 = o1.getName();
String name2 = o2.getName();
//先按照name排序 如果不等于0，则按name排序，等于0则按生日日期
if (name1.compareTo(name2) != 0) {
return name1.compareTo(name2);
}
//按照年月日进行排序
MyDate bir1 = o1.getBirthday();
MyDate bir2 = o2.getBirthday();
return bir1.compareTo(bir2);
}
});
//遍历
for (Employee employee : employeelist) {
System.out.println(employee);
}
}
}
/**
* 定义Employee:类
* 1)该类包含：private成员变量name,sal,birthday,其中birthday为MyDate类的对象
* 2)为每一个属性定义getter,,setter方法：
* 3)重写toString方法输出name,sal,birthday
* 4)MyDate类包含：private成员变量month,day,year;并为每一个属性定义getter,setter方法；
* 5)创建该类的3个对象，并把这些对象放入ArrayList集合中(ArrayList需使用泛型来定义)，
* 对集合中的元素进行排序，并遍历输出：
* 排序方式：调用ArrayList的sort方法，传入Comparator对象[使用泛型]，
* 先按照name排序，如果name相同，则按生日日期的先后排序。
*/
class Employee {
private String name;
private double sal;
private final MyDate birthday;
public MyDate getBirthday() {
return birthday;
}
@Override
public String toString() {
return "Employee{" +
"name='" + name + '\'' +
", sal=" + sal +
", birthday=" + birthday +
'}';
}
public Employee(String name, double sal, MyDate birthday) {
this.name = name;
this.sal = sal;
this.birthday = birthday;
}
public double getSal() {
return sal;
}
public void setSal(double sal) {
this.sal = sal;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
class MyDate implements Comparable<MyDate> {
private int year;
private int month;
private int day;
public int getYear() {
return year;
}
public void setYear(int year) {
this.year = year;
}
@Override
public String toString() {
return year + "/" + month + "/" + day;
}
public int getMonth() {
return month;
}
public void setMonth(int month) {
this.month = month;
}
public int getDay() {
return day;
}
public void setDay(int day) {
this.day = day;
}
public MyDate(int year, int month, int day) {
this.year = year;
this.month = month;
this.day = day;
}
@Override
public int compareTo(MyDate o) {
//比较年月日，升序
int cmpyear = year - o.getYear();
int cmpmonth = month - o.getMonth();
int cmpday = day - o.getDay();
if (cmpyear != 0) {
return cmpyear; //年
}
if (cmpmonth != 0) {
return cmpmonth; //月
}
return cmpday; //日
}
}
自定义泛型
泛型类
基本语法
class 类名<T,R...>{
成员;
}
注意事项
- 普通成员可以使用泛型（属性、方法）
- 使用泛型的数组，不能初始化（因为数组在new 不能确定T的类型，就无法在内存开空间）
- 泛型类的类型，是在创建对象时确定的（因为创建对象时，需要指定确定类型）
- 静态方法中不能使用类的泛型
- 如果在创建对象时，没有指定类型，默认为Object
泛型接口
基本语法
interface 接口名<T,R...>{}
注意事项
- 静态成员不能使用泛型
- 泛型接口的类型，在继承接口或者实现接口时确定
- 没有指定类型，默认为Object
泛型方法
基本语法
修饰符<T,R...>返回类型 方法名(参数列表){}
注意事项
-
泛型方法，可以定义在普通类中，也可以定义在泛型类中
-
当泛型方法被调用时，类型会确定
-
public void eat(E e) {},
修饰符后没有<T,R...＞ eat
方法不是泛型方法，而是使用了泛型
泛型的继承和通配符
注意事项
-
泛型不具备继承性
-
< ? >：支持任意泛型类型
-
< ? 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<>();
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<?> 表示 任意的泛型类型都可以接受
public static void printCollection1(List<?> c) {
for (Object object : c) { // 通配符，取出时，就是Object
System.out.println(object);
}
}
// ? extends AA 表示 上限，可以接受 AA或者AA子类
public static void printCollection2(List<? extends AA> c) {
for (Object object : c) {
System.out.println(object);
}
}
// ? super 子类类名AA:支持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 {
}
JUnit
package testGeneric.testJUnit;
import org.junit.jupiter.api.Test;
public class Test1 {
public static void main(String[] args) {
}
}
//加上Test可以直接测试方法
class A{
@Test
public void m1(){
System.out.println("m1");
}
@Test
public void m2(){
System.out.println("m2");
}
}