泛型：标签
集合容器类在设计阶段/声明阶段不能确定这个容器到底实际存的是什么类型的对象，所以在JDK1.5之前只能把元素类型设计为Object，JDK1.5之后使用泛型来解决。因为这个时候除了元素的类型不确定，其他的部分是确定的，例如关于这个元素如何保存，如何管理等是确定的，因此此时把元素的类型设计成一个参数，这个类型参数叫做泛型。Collection<E>，List<E>，ArrayList<E>这个<E>就是类型参数，即泛型。
所谓泛型，就是允许在定义类、接口时通过一个标识表示类中某个属性的类型或者是某个方法的返回值及参数类型。这个类型参数将在使用时（例如，继承或实现这个接口，用这个类型声明变量、创建对象时）确定（即传入实际的类型参数,也称为类型实参)。
在集合中使用泛型的情况，以ArrayList举例
ArrayList<Integer> list = new ArrayList<Integer>();
list.add(78);
list.add(45);
list.add(78);
list.add(99);
//编译时就会进行类型检查
//list.add("abc");
?
for(Integer score :list){
//避免了强转操作
int stuScore = score;
System.out.println(stuScore);
}
?
Iterator<Integer> iterator = list.iterator();
while (iterator.hasNext()){
int stuScore = iterator.next();
System.out.println(stuScore);
}
在集合中使用泛型的情况，以HashMap举例
Map<String, Integer> map = new HashMap<>();
map.put("Tom", 87);
map.put("Jerry", 67);
map.put("mike", 97);
map.put("hong", 87);
?
Set<Map.Entry<String, Integer>> entry = map.entrySet();
Iterator<Map.Entry<String,Integer>> iterator = entry.iterator();
?
while(iterator.hasNext()){
Map.Entry<String, Integer> entry1 = iterator.next();
String key = entry1.getKey();
Integer value = entry1.getValue();
System.out.println(key + "---------"+value);
}
总结：
集合接口或集合类在jdk5.0时都修改带泛型的结构
在实例化集合类时，可以指明具体的泛型类型
指明完以后，在集合类或接口凡是定义类或接口时，内部结构使用到类的泛型的位置，都指定为实例化的泛型类型
比如：add(E e) -----> 实例化以后，add(Integer e)
注意点：泛型的类型必须是类，不能是基本数据类型，需要用到基本数据类型的位置，拿包装类替换
如果实例化时，没有指明泛型的类型，默认类型为java.lang.Object类型
泛型类、泛型接口、泛型方法
泛型类可能有多个参数，此时应该多个参数一起放到尖括号内<e1,e2,e3>
泛型不同的引用不能相互赋值
异常类不能申明为泛型类
静态方法不能使用类的泛型
数组创建 T[] arr = (T[]) new Object[10]
public class Order<T> {
?
String orderName;
int orderId;
?
//类的内部结构就可以使用类的泛型
?
T orderT;
?
public Order(){}
?
public Order(String orderName,int orderId,T orderT){
this.orderName = orderName;
this.orderId = orderId;
this.orderT = orderT;
?
}
?
public T getOrderT(){
return orderT;
}
?
public void setOrderT(T orderT) {
this.orderT = orderT;
}
?
子类继承父类 两种
public class SubOrder extends Order<Integer>{////SubOrder:不是个泛型类
}
?
SubOrder subOrder = new SubOrder();
//由于子类继承了带泛型的父类时，则实例化子类对象时，不再需要指明泛型
subOrder.setOrderT(1112);
public class SubOrder1<T> extends Order<T>{//SubOrder1<T>:仍然时个泛型类
}
?
SubOrder1<String> subOrder1 = new SubOrder1<>();
subOrder1.setOrderT("order2");
泛型方法：在方法中出现了泛型的结构，泛型参数与类的泛型参数没有关系
换句话说，泛型方法所属的类是不似乎泛型类都没有关系
泛型方法可以声明为静态的，原因：泛型参数是在调用方法时确定的，并非在实例化类时确定
public <E> List<E> copyFromArrayList(E[] arr){
ArrayList<E> arrayList = new ArrayList<>();
for(E e:arr){
arrayList.add(e);
}
return arrayList;
}
?
//泛型方法 不确定 E是表示返回值类型，<E>是指明该方法中使用了泛型E
public void <E> E getValue(){
return null;
}
public void test3(){
Order<String> order = new Order<>();
Integer[] arr = new Integer[]{1,2,3,4};
List<Integer> integers = order.copyFromArrayList(arr);
}
?
?
泛型在继承方面的体现
虽然类A是类B的父类，但是G<A> 和 G<B>二者不具备子父类关系，二者是并列关系
List<Object> list1 = null;
List<String> list2 = null;
//此时的list1 和 list2 不具有子父类关系
//编译不通过
list1 = list2;
通配符使用：？
类A是类B的父类， G<A>和 G<B>是没有关系的，二者共同的父类是：G<?>
对于List<?>就不能向其内部添加数据，除了添加null之外
// list1.add("dd");
// list1.add("?");
?
list1.add(null);
//读取：
Object o = list1.get(0);
System.out.println(o);
有限制条件的通配符使用
？ extends A：
G<? extends A> 可以作为G<A> 和 G<B>的父类，其中 B 是 A的子类
？ super A：
G<? extends A> 可以作为G<A> 和 G<B>的父类，其中 B 是 A的父类
List<? extends Person> list1 = null;
List<? super Person> list2 = null;
?
List<Student> list3 = null;
List<Person> list4 = null;
List<Object> list5 = null;
?
list1 = list3;
list1 = list4;
//list1 = list5;
?
// list2 = list3;
list2 = list4;
list2 = list5;
实例
public 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){
if(map.containsKey(id)){
map.put(id,entity);
}
}
?
public List<T> list(){
List<T> list = new ArrayList<>();
Collection<T> values = map.values();
for(T t : values){
list.add(t);
}
return list;
}
?
public void delete(String id){
map.remove(id);
}
}
?
?
public class User {
private int id;
private int age;
private String name;
?
public User() {
}
?
public User(int id, int age, String name) {
this.id = id;
this.age = age;
this.name = name;
}
?
public int getId() {
return id;
}
?
public int getAge() {
return age;
}
?
public String getName() {
return name;
}
?
public void setId(int id) {
this.id = id;
}
?
public void setAge(int age) {
this.age = age;
}
?
public void setName(String name) {