泛型

泛型

• 和C++中的模板差不多
• 在给泛型指定具体类型后，可以传入该类型或者其子类类型
• 自定义泛型不能够和static共同修饰成员 因为static修饰的是类变量，伴随着类的建立，而泛型类型是未确定类型，显然不能一起使用
• 泛型没有继承性

Comparable和Comparator的比较

Comparator 对应 compare 一般用于业务排序，例如对多组数据进行排序时，限定排序规则
Comparable 对应 compareTo 一般用于类实体 进行规定类的排序规则

例子

//Comparator 对应  compare
ArrayList<Employee> employees = new ArrayList<>();
employees.sort(new Comparator<Employee>() {     //实现接口的匿名内部类
 @Override
 public int compare(Employee o1, Employee o2) {
     return o1.compareTo(o2);
 }
});
//Comparable 对应  compareTo		String 等常用类大都实现了compareTo方法
class MyDate implements Comparable<MyDate> {
 private int year;
 private int month;
 private int day;
 @Override
 public int compareTo(MyDate o) {        //自定义比较规则
     int i = year - o.year;
     if (i != 0) return i;
     int j = month - o.month;
     if (j != 0) return j;
     int k = day - o.day;
     return k;
 }
}

自定义泛型接口

• 在接口中，静态成员也是不能使用泛型

• 泛型接口的类型，是在继承接口或者实现接口时确定

• 没用指定类型，默认为Object

  package Generic;
  public class Generic_03 {
  }
  interface A<T, R> {
      void solve1(T t);
      void solve2(R r);
      //T name;不能这样使用,因为在接口中的普通成员一般是静态的
      public static final int a = 2;
  }
  interface B extends A<Double, String> {     //如果这里没指定类型那也是Object
  }
  class C implements B {
      @Override
      public void solve1(Double aDouble) {
      }
      @Override
      public void solve2(String s) {
      }
  }
  class D implements A{       //也可以指定类型A<类型,类型>
      @Override
      public void solve1(Object o) {      //没有指定类型默认为Object
      }
      @Override
      public void solve2(Object o) {
      }
  }
  

泛型的继承和通配符说明

• 只是针对于泛型类而言
• <?> 支持任意类型
• <? extends A> 支持A类及A类的子类，规定泛型的上限
• <? super A> 支持A类及A类的父类，不限于直接父类，规定了泛型的下限

package Generic;
import java.util.ArrayList;
import java.util.List;
@SuppressWarnings({"all"})
public class Generic_02 {
    public static void main(String[] args) {
        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<>();
        //<?>
        fun1(list1);
        fun1(list2);
        fun1(list3);
        fun1(list4);
        fun1(list5);
        //<? extends A>
        //fun2(list1);Object
        //fun2(list2);String
        fun2(list3);//A本类
        fun2(list4);//A子类
        fun2(list5);//A间接子类
        //<? super A>
        fun3(list1);//Object是任何类的父类
        //fun3(list2);String和本类没有继承关系
        fun3(list3);//A本类
        //fun3(list4);B类
        //fun3(list5);C类
    }
    public static void fun1(List<?> t) {
    }
    public static void fun2(List<? extends AA> t) {
    }
    public static void fun3(List<? super AA> t) {
    }
}
class AA {}
class BB extends AA {}
class CC extends BB {}
class DD<T, R> {
    public void fun(DD<?, ?> t) {
    }
}

小案例

package Generic;
import org.junit.jupiter.api.Test;
import java.util.*;
public class Generic_text {
    public static void main(String[] args) {
    }
    @Test
    public void test01() {
        DAO<User> dao = new DAO<>();
        dao.save("001", new User(1,9,"tom"));
        dao.save("002", new User(2,18,"syj"));
        dao.save("003", new User(3,22,"sxy"));
        dao.save("004", new User(4,2,"xhj"));
        List<User> list = dao.list();
        System.out.println(list);
    }
}

class User {
    private int id;
    private int age;
    private String name;
    public User(int id, int age, String name) {
        this.id = id;
        this.age = age;
        this.name = name;
    }
    public int getId() { return id; }
    public void setId(int id) { this.id = id; }
    public int getAge() { return age; }
    public void setAge(int age) { this.age = age; }
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    @Override
    public String toString() {
        return "\nUser{" +"id=" + id +", age=" + age +", name='" + name + '\'' +'}';
    }
}
class DAO<T> {
    private Map<String, T> map = new HashMap<>();
    public void save(String id, T entity) {
        map.put(id, entity);
    }
    public T get(String id) { return map.get(id); }
    public void update(String id, T entity) { map.put(id, entity); }
    public void delete(String id) { map.remove(id); }
    public List<T> list() {
        List<T> list = new ArrayList<>();
        Set<String> set = map.keySet();
        for (String s : set) {
            list.add(get(s));
        }
        return list;
    }
}