第七天泛型
public class Student<E> { //泛型父类
?
String name = "123";
E age;
?
public Student(){}
?
?
public Student(String name,E age){
this.name = name;
this.age = age;
}
?
public void setName(String name) {
this.name = name;
}
?
public void setAge(E age) {
this.age = age;
}
}
?
public class Son extends Student<Integer>{ //子类继承时指明父类的泛型
?
String name;
String age;
?
public Son(){}
?
public Son(String name,String age){
this.name = name;
this.age = age;
}
}
?
public static void main(String[] args) {
//如果定义了泛型类，实例化没指名泛型类型则默认是Object类
//要求：如果定义了泛型类，那么建议在实例化时指明类的泛型
Student s1 = new Student();
s1.setAge("ABC");
s1.setAge(123);
//建议：实例化时指明泛型类类型
Student<Integer> s2 = new Student<>("任",21);
?
Son son = new Son();
//子类在继承泛型父类是指明了父类泛型，实例化子类对象时不需再添加泛型
son.setAge(123); //已经默认是Integer了
?
?
}
泛型方法
-
在方法中出现了泛型的结构，泛型参数与类的泛型参数没有任何关系
-
泛型方法所属的类是不是泛型类没有关系
-
泛型方法可以声明为静态的，原因：泛型参数是在调用方法时确定的，并非在实例化类时确定。
public <E> List<E> copy(E[] arr){
List<E> list = new ArrayList<>();
for(E e: arr){
list.add(e);
}
return list;
}
Son son1 = new Son();
Integer[] integer = new Integer[]{1,5,3,4};
List<Integer> list = son1.copy(integer);
System.out.println(list);
?
泛型在继承中的体现
-
类A是类B的父类那么 G和G二者不具备子父类关系二者是并列关系。
-
类A是类B的父类那么 A
和B 二者是子父类关系
Object obj = null;
String str = null;
obj = str;
?
Object[] obj1 = null;
String[] str1 = null;
obj1 = str1;
?
List<Object> list1= null;
List<String> list2 = null;
?
//此时的list1和list2不具有子父类关系
list1 = list2; //编译报错
通配符的使用
-
类A是类B的父类那么 G和G二者没有关系，二者共同的父类是：G<?>
public static void main(String[] args) {
?
List
有条件限制的通配符的使用
public static void main(String[] args) {
?
List<? extends Student> list1 = null;
List<? super Student> list2 = null;
?
List<Student> list3 = new ArrayList<>();
List<Son> list4 = new ArrayList<>();
List<Person> list5 = new ArrayList<>();
?
?
?
//编译报错
// list1 = list5;
Student s = list1.get(0);
Object obj = list1.get(0);
//编译报错
// Son son = list1.get(0);
?
list2 = list3;
Object o = list2.get(0);
//编译报错
// Person person = list2.get(0);
?
?
/*
*没有下限无法往list1里面写入数据
*因为他的继承是[Student,-无穷]，所以类可能会很小
* 比Son还小，再因为父类无法往子类中写入数据
* 所以Son，Student，Person都无法比他们还小的
* 类中写入数据.
*/
// list1.add(new Student());
// list1.add(new Person());
// list1.add(new Son());
?
?
/*
*而这里的范围是[+无穷，Student]
*所以只要写入的数据小于等于Student就能成功写入
*/
list2.add(new Student());
list2.add(new Son());
//编译报错
// list2.add(new Person());
?
?
}
}
泛型练习题
package com.Map.Test;
?
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Map;
?
public class DAO<T> {
?
private Map<String,T> map;
?
public DAO(){}
?
public DAO(Map<String,T> map){
this.map = map;
}
?
public void save(String id,T entity){
map.put(id, entity);
}
?
public T get(String id){
T t = map.get(id);
return t;
}
?
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> colle = map.values();
for (T value : colle) {
list.add(value);
}
return list;
}
?
public void delete(String id){
map.remove(id);
}
?
public Map<String, T> getMap() {
return map;
}
?
public void setMap(Map<String, T> map) {
this.map = map;
}
}
?
?
package com.Map.Test;
?
import java.util.Objects;
?
public class User {
?
private int id;
private int age;
private String