JAVASE

1.泛型

泛型指类型参数化， 在定义期间，不知道调用时会使用什么类型，就可以添加泛型形参，在使用时传入实参固定类型即可。

泛型类： 泛型应用在类上。 一般用在类名后，用尖括号括起来。用大写字母作为泛型参数。

我们可以通过一个实例更好的理解

public class Person<T> {private T idCard;public Person(T idCard) {this.idCard = idCard;}

我们首先定义了一个Person类，并提供泛型<T>，在传入成员变量时，就可以使用泛型来定义成员变量的类型，因为我们不知道在创建对象时会传入什么类型的对象，在提供构造器时，形参的类型就规定成泛型；

public static void main(String[] args) {//测试：创建一个Person对象,需要给泛型参数赋值具体类型Person<String> P = new Person<>("1001");Person<Long> p3 = new Person<>(1001L);//泛型参数只能使用引用类型，不能能赋值八大基本数据类型//实例化过程中，泛型可以只在一边给泛型参数赋值，但是两边的<>不能省略}

在这里我们传入一个测试方法，分别调用构造器创建两个不同类型的Person对象；在类名后添加传入的实际类型就可以。需要注意：传入的实际类型不能是基本数据类型，因为他们没有面向对象的特征；只能传入引用数据类型；比如包装类或字符串类型；

当有一个子类继承带有泛型的父类时，一般需要给泛型传入实际类型

class Student extends Person<Integer> {public Student(Integer idcard) {super(idcard);}
}

需要注意的是，在继承父类之后，需要重写父类的构造方法；

子类在继承带有泛型的父类时，如果子类自己也添加了泛型，可以把泛型传入父类

class Teacher<E> extends Person<E> {public Teacher(E idcard) {super(idcard);}
}

需要注意的是，子类在继承父类后，需要把自己的泛型赋值给父类

如果子类不传入实际类型也不使用泛型，那么子类默认使用Object泛型

class President extends Person {public President(Object idcard) {super(idcard);}
}

2.泛型接口

如果泛型应用在接口上，就成为泛型接口；

public interface MyComparable<T, M> {}

在定义泛型接口时，也可以使用泛型，这个比较接口就传入了两个泛型

class Employee implements MyComparable<Employee, Employee>, Comparator<Employee> {String name;int age;public Employee(String name, int age) {this.name = name;this.age = age;}public String toString() {return "[" + name + ":" + age + "]";}//在我们自己定义的方法中实现比较规则@Overridepublic int mycompare(Employee o1, Employee o2) {return o1.age - o2.age;}public int compare(Employee o1, Employee o2) {return mycompare(o1, o2);}
}

我们定义了一个类来实现两个接口，一个是自定义的比较接口，一个是比较器接口，传入的类型都是定义的Employee类型，之后定义了两个成员变量，年龄和姓名；提供了全参构造器并重写了toString方法，并在我们自己定义的方法中确定比较原则，按照年龄升序，然后重写compare方法，返回值就是我们自己定义的方法，传入o1，o2.

public static void main(String[] args) {Employee[] employees = new Employee[3];employees[0] = new Employee("小张", 18);employees[1] = new Employee("小王", 17);employees[2] = new Employee("小李", 19);
//使用比较器接口，来重新定义比较规则：从泛型的角度来说，在实例化泛型接口时，要给泛型参数传具体类型Comparator c = new Comparator<Employee>() {//重写比较器里的compare方法public int compare(Employee o1, Employee o2) {//调用了自定义的员工类里的比较方法return o1.mycompare(o1, o2);}};Arrays.sort(employees, c);System.out.println(Arrays.toString(employees));}

在main方法里，我们首先建立了Employee类型的数组，并传入了三个值，之后再=在使用比较器接口，新建一个比较器对象，需要使用匿名内部类的方式；重写compare方法，调用主类中自己定义的比较规则方法就可以了，之后对数组进行排序，传入数组和比较器对象；然后对其打印

3.泛型方法

泛型可以应用在方法上，位置位于返回值类型的前面；

public static <T>  boolean equals(T t1,T t2){return t1.equals(t2);}

首先定义一个泛型方法，在boolean前面添加泛型，形参也是泛型对象；返回对象调用equals的结果，

class Cat{String name;public Cat(String name){this.name = name;}@Overridepublic boolean equals(Object o) {if (this == o) return true;if (o == null || getClass() != o.getClass()) return false;Cat cat = (Cat) o;return Objects.equals(name, cat.name);}@Overridepublic int hashCode() {return Objects.hashCode(name);}
}

我们在主类Cat中需要重写equals和hashCode方法，可以直接生成，也可以自己撸代码；

public static void main(String[] args) {Cat c1 = new Cat("小黄");Cat c2 = new Cat("小黄");//泛型方法在调用期间不需要传入具体类型，只需要传入具体对象，编译器会自动推断对象的类型//泛型方法调用期间并没有给泛型参数赋值，下面的案例是c1给t1赋值，c2给t2赋值，没有给T赋值。boolean equals = MyUtil.equals(c1, c2);System.out.println("equals: " + equals);}

之后我们可以在main方法中创建两个对象并通过类名调用equals方法，并打印结果。

4.泛型通配符

?  泛型通配符 ，表示不关心调用时传入的类型

/*** 将集合元素打印到控制台上*/public static void print(List<?> list){for(int i = 0;i<list.size();i++){System.out.println(list.get(i));}}

先定义一个方法，将集合中的元素打印到控制台，可以定义一个泛型的形参，使用经典for循环，遍历并打印出集合的每个元素

/*** 上边界的定义  <? extends 具体类名>*     具体调用的时候，可以是上边界的任何子类型或本类型* @param list*/public static void print2(List <? extends Number> list) {for(int i = 0;i<list.size();i++){System.out.println(list.get(i));}}

上边界的定义，指的就是调用方法时，需要传入的类型的形式只能时其本类型或者其子类型，使用上边界时，需要在形参传入泛型时改变<？extends 具体类型（上边界）>之后的方法体不需要改变；

/*** 下边界的定义： <? super 具体类名>*     具体使用的时候，可以是下边界的任何父类型或者本类型*/public static void print3(List <? super Integer> list) {for(int i = 0;i<list.size();i++){System.out.println(list.get(i));}}

下边界的定义，指的就是在调用方法时，需要传入的类型的形式只能是其本类型或其夫类型，传入的泛型需要改变为<? super 具体类型（下边界）>

 public static void main(String[] args) {List<Integer> nums = new ArrayList<Integer>();nums.add(1);nums.add(2);nums.add(3);MyUtil.print(nums);//上边界的测试print2(new ArrayList<Long>());print2(new ArrayList<Number>());//下边界的测试print3(new ArrayList<Integer>());print3(new ArrayList<Number>());print3(new ArrayList<Object>());//没有关系
//        print3(new ArrayList<Long>());}

在测试时，首先建立一个Integer类型的集合，并添加元素；然后使用print方法打印；

在测试上边界时，定义的上边界是Number,我们传入的泛型可以是子类Long类型，也可以是子类Integer，也可以是本类Number

在测试下边界时，定义的下边界是Integer,我们传入的泛型可以是父类Number类型，也可以是父类Object，也可以是本类Integer