文章目录
文章目录
全部源码：https://github.com/name365/JavaSE-30Day
第12章 泛型
为什么要有泛型
- 泛型：标签
- 举例：
- 中药店，每个抽屉外面贴着标签
- 超市购物架上很多瓶子，每个瓶子装的是什么，有标签。
- 泛型的设计背景
集合容器类在设计阶段/声明阶段不能确定这个容器到底实际存的是什么类型的对象，所以 在JDK1.5之前只能把元素类型设计为Object，JDK1.5之后使用泛型来解决。因为这个时候除了元素的类型不确定，其他的部分是确定的，例如关于这个元素如何保存，如何管理等是确定的，因此此时 把元素的类型设计成一个参数，这个类型参数叫做泛型。Collection，List，ArrayList这个就是类型参数，即泛型。
- 所谓泛型，就是允许在定义类、接口时通过一个标识表示类中某个属性的类型或者是某个方法的返回值及参数类型。这个类型参数将在使用时（例如，继承或实现这个接口，用这个类型声明变量、创建对象时）确定（即传入实际的类型参数，也称为类型实参）。
- 从JDK1.5以后，Java引入了"参数化类型（Parameterizedtype）"的概念，允许我们在创建集合时再指定集合元素的类型，正如：List，这表明该List只能保存字符串类型的对象。
- JDK1.5改写了集合框架中的全部接口和类，为这些接口、类增加了泛型支持，从而可以在声明集合变量、创建集合对象时传入类型实参。
那么为什么要有泛型呢，直接Object不是也可以存储数据吗？
1.解决元素存储的安全性问题，好比商品、药品标签，不会弄错。2.解决获取数据元素时，需要类型强制转换的问题，好比不用每回拿商品、药品都要辨别。
Java泛型可以保证如果程序在编译时没有发出警告，运行时就不会产生ClassCastException异常。同时，代码更加简洁、健壮。
import org.junit.Test;
import java.util.ArrayList;
public class GenericTest {
@Test
public void test(){
ArrayList list = new ArrayList();
list.add(78);
list.add(49);
list.add(72);
list.add(81);
list.add(89);
for(Object score : list){
int stuScore = (Integer)score;
System.out.println(stuScore);
}
}
}
在集合中使用泛型
举例
import org.junit.Test;
import java.util.*;
public class GenericTest {
@Test
public void test3(){
Map<String,Integer> map = new HashMap<>();
map.put("Tom",87);
map.put("Tone",81);
map.put("Jack",64);
Set<Map.Entry<String,Integer>> entry = map.entrySet();
Iterator<Map.Entry<String, Integer>> iterator = entry.iterator();
while(iterator.hasNext()){
Map.Entry<String, Integer> e = iterator.next();
String key = e.getKey();
Integer value = e.getValue();
System.out.println(key + "----" + value);
}
}
@Test
public void test2(){
ArrayList<Integer> list = new ArrayList<Integer>();
list.add(78);
list.add(49);
list.add(72);
list.add(81);
list.add(89);
Iterator<Integer> iterator = list.iterator();
while(iterator.hasNext()){
int stuScore = iterator.next();
System.out.println(stuScore);
}
}
}
练习
- 练习1
- MyDate类
public 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;
}
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() {
}
public MyDate(int year, int month, int day) {
this.year = year;
this.month = month;
this.day = day;
}
@Override
public String toString() {
return "MyDate{" +
"year=" + year +
", month=" + month +
", day=" + day +
'}';
}
@Override
public int compareTo(MyDate m) {
int minusYear = this.getYear() - m.getYear();
if(minusYear != 0){
return minusYear;
}
int minusMonth = this.getMonth() - m.getMonth();
if(minusMonth != 0){
return minusMonth;
}
return this.getDay() - m.getDay();
}
}
- Employee类
public class Employee implements Comparable<Employee>{
private String name;
private int age;
private MyDate birthday;
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 MyDate getBirthday() {
return birthday;
}
public void setBirthday(MyDate birthday) {
this.birthday = birthday;
}
public Employee() {
}
public Employee(String name, int age, MyDate birthday) {
this.name = name;
this.age = age;
this.birthday = birthday;
}
@Override
public String toString() {
return "Employee{" +
"name='" + name + '\'' +
", age=" + age +
", birthday=" + birthday +
'}';
}
@Override
public int compareTo(Employee o) {
return this.name.compareTo(o.name);
}
}
- 测试类
import org.junit.Test;
import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;
public class EmployeeTest {
@Test
public void test2(){
TreeSet<Employee> set = new TreeSet<>(new Comparator<Employee>() {
@Override
public int compare(Employee o1, Employee o2) {
MyDate b1 = o1.getBirthday();
MyDate b2 = o2.getBirthday();
return b1.compareTo(b2);
}
});
Employee e1 = new Employee("liudehua",55,new MyDate(1965,5,4));
Employee e2 = new Employee("zhangxueyou",43,new MyDate(1987,5,4));
Employee e3 = new Employee("guofucheng",44,new MyDate(1987,5,9));
Employee e4 = new Employee("liming",51,new MyDate(1954,8,12));
Employee e5 = new Employee("liangzhaowei",21,new MyDate(1978,12,4));
set.add(e1);
set.add(e2);
set.add(e3);
set.add(e4);
set.add(e5);
Iterator<Employee> iterator = set.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
}
@Test
public void test(){
TreeSet<Employee> set = new TreeSet<Employee>();
Employee e1 = new Employee("wangxianzhi",41,new MyDate(334,5,4));
Employee e2 = new Employee("simaqian",43,new MyDate(-145,7,12));
Employee e3 = new Employee("yanzhenqin",44,new MyDate(709,5,9));
Employee e4 = new Employee("zhangqian",51,new MyDate(-179,8,12));
Employee e5 = new Employee("quyuan",21,new MyDate(-340,12,4));
set.add(e1);
set.add(e2);
set.add(e3);
set.add(e4);
set.add(e5);
Iterator<Employee> iterator = set.iterator();
while (iterator.hasNext()){
Employee next = iterator.next();
System.out.println(next);
}
}
}
自定义泛型结构
自定义泛型类举例
- OrderTest类
public class OrderTest<T> {
String orderName;
int orderId;
T orderT;
public OrderTest(){
};
public OrderTest(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;
}
@Override
public String toString() {
return "Order{" +
"orderName='" + orderName + '\'' +
", orderId=" + orderId +
", orderT=" + orderT +
'}';
}
}
- SubOrder类
public class SubOrder extends OrderTest<Integer>{
}
- SubOrder1类
public class SubOrder1<T> extends OrderTest<T> {
}
- GenericTest1类
import org.junit.Test;
public class GenericTest1 {
@Test
public void test(){
OrderTest order = new OrderTest();
order.setOrderT(123);
order.setOrderT("ABC");
OrderTest<String> order1 = new OrderTest<String>("orderAA",1001,"order:AA");
order1.setOrderT("AA:hello");
}
@Test
public void test2(){
SubOrder sub1 = new SubOrder();
sub1.setOrderT(1122);
SubOrder1<String> sub2 = new SubOrder1<>();
sub2.setOrderT("order2...");
}
}
自定义泛型类泛型接口的注意点
-
泛型类可能有多个参数，此时应将多个参数一起放在尖括号内。比如：
-
泛型类的构造器如下：public GenericClass(){}。而下面是错误的：public GenericClass(){}
-
实例化后，操作原来泛型位置的结构必须与指定的泛型类型一致。
-
泛型不同的引用不能相互赋值。>尽管在编译时ArrayList和ArrayList是两种类型，但是，在运行时只有一个ArrayList被加载到JVM中。
-
泛型如果不指定，将被擦除，泛型对应的类型均按照Object处理，但不等价于Object。经验：泛型要使用一路都用。要不用，一路都不要用。
-
如果泛型结构是一个接口或抽象类，则不可创建泛型类的对象。
-
jdk1.7，泛型的简化操作：ArrayList flist = new ArrayList<>();
-
泛型的指定中不能使用基本数据类型，可以使用包装类替换。
-
在类/接口上声明的泛型，在本类或本接口中即代表某种类型，可以作为非静态属性的类型、非静态方法的参数类型、非静态方法的返回值类型。但在静态方法中不能使用类的泛型。
-
异常类不能是泛型的
-
不能使用new E[]。但是可以：E[] elements = (E[])new Object[capacity];参考：ArrayList源码中声明：Object[] elementData，而非泛型参数类型数组。
- Person类
public class Person {
}
- OrderTest类
public class OrderTest<T> {
String orderName;
int orderId;
T orderT;
public OrderTest(){
T[] arr = (T[]) new Object[10];
};
public OrderTest(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;
}
@Override
public String toString() {
return "Order{" +
"orderName='" + orderName + '\'' +
", orderId=" + orderId +
", orderT=" + orderT +
'}';
}
public void show(){
}
}
- GenericTest1类
import org.junit.Test;
import java.util.ArrayList;
public class GenericTest1 {
@Test
public void test3(){
ArrayList<String> list1 = null;
ArrayList<Integer> list2 = new ArrayList<Integer>();
Person p1 = null;
Person p2 = null;
p1 = p2;
}
}
- 父类有泛型，子类可以选择保留泛型也可以选择指定泛型类型： 子类不保留父类的泛型：按需实现
- 没有类型擦除
- 具体类型 子类保留父类的泛型：泛型子类
- 全部保留
- 部分保留
class Father<T1, T2> {}
class Son1 extends Father {
}
class Son2 extends Father<Integer, String> {}
class Son3<T1, T2> extends Father<T1, T2> {}
class Son4<T2> extends Father<Integer, T2> {}
结论：子类必须是"富二代"，子类除了指定或保留父类的泛型，还可以增加自己的泛型。
自定义泛型方法举例
- 方法，也可以被泛型化，不管此时定义在其中的类是不是泛型类。在泛型方法中可以定义泛型参数，此时，参数的类型就是传入数据的类型。
- 泛型方法的格式：
[访问权限]
- OrderTest类
import java.util.ArrayList;
import java.util.List;
public class OrderTest<T> {
public static <E> List<E> copyFromArrayToList(E[] arr){
ArrayList<E> list = new ArrayList<>();
for(E e : arr){
list.add(e);
}
return list;
}
}
- 测试类
import org.junit.Test;
import java.util.ArrayList;
import java.util.List;
public class GenericTest1 {
@Test
public void test4(){
OrderTest<String> order = new OrderTest<>();
Integer[] arr = new Integer[]{1,2,3,4};
List<Integer> list = order.copyFromArrayToList(arr);
System.out.println(list);
}
}
- SubOrder类
import java.util.ArrayList;
import java.util.List;
public class SubOrder extends OrderTest<Integer>{
public static <E> List<E> copyFromArrayToList(E[] arr){
ArrayList<E> list = new ArrayList<>();
for(E e : arr){
list.add(e);
}
return list;
}
}
举例泛型类和泛型方法的使用情境
- DAO类
import java.util.List;
public class DAO<T> {
public void add(T t){
}
public boolean remove(int index){
return false;
}
public void update(int index,T t){
}
public T getIndex(int index){
return null;
}
public List<T> getForList(int index){
return null;
}
public <E> E getValue(){
return null;
}
}
- Customer类
public class Customer {
}
- CustomerDAO类
public class CustomerDAO extends DAO<Customer>{
}
- Student类
public class Student {
}
- StudentDAO类
public class StudentDAO extends DAO<Student> {
}
- DAOTest类
import org.junit.Test;
import java.util.List;
public class DAOTest {
@Test
public void test(){
CustomerDAO dao1 = new CustomerDAO();
dao1.add(new Customer());
List<Customer> list = dao1.getForList(10);
StudentDAO dao2 = new StudentDAO();
Student student = dao2.getIndex(1);
}
}
泛型在继承上的体现
import org.junit.Test;
import java.util.AbstractList;
import java.util.ArrayList;
import java.util.List;
public class GenericTest {
@Test
public void test(){
Object obj = null;
String str = null;
obj = str;
Object[] arr1 = null;
String[] arr2 = null;
arr1 = arr2;
List<Object> list1 = null;
List<String> list2 = new ArrayList<String>();
show(list1);
show2(list2);
}
public void show2(List<String> list){
}
public void show(List<Object> list){
}
@Test
public void test2(){
AbstractList<String> list1 = null;
List<String> list2 = null;
ArrayList<String> list3 = null;
list1 = list3;
list2 = list3;
List<String> list4 = new ArrayList<>();
}
}
通配符的使用
- 使用类型 通配符：？
- 比如：List ，Map
- List是List、List等各种泛型List的父类。
- 读取List的对象list中的元素时，永远是安全的，因为不管list的真实类型是什么，它包含的都是Object。
- 写入list中的元素时，不行。因为我们不知道c的元素类型，我们不能向其中添加对象。
- 唯一的例外是null，它是所有类型的成员。
- 将任意元素加入到其中不是类型安全的：
- Collection c = new ArrayList();
- c.add(new Object()); // 编译时错误因为我们不知道c的元素类型，我们不能向其中添加对象。add方法有类型参数E作为集合的元素类型。我们传给add的任何参数都必须是一个未知类型的子类。因为我们不知道那是什么类型，所以我们无法传任何东西进去。
- 唯一的例外的是null，它是所有类型的成员。
- 另一方面，我们可以调用get()方法并使用其返回值。返回值是一个未知的类型，但是我们知道，它总是一个Object。
import org.junit.Test;
import java.util.AbstractList;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class GenericTest {
@Test
public void test3(){
List<Object> list1 = null;
List<String> list2 = null;
List<?> list = null;
list = list1;
list = list2;
print(list1);
print(list2);
}
public void print(List<?> list){
Iterator<?> iterator = list.iterator();
while(iterator.hasNext()){
Object obj = iterator.next();
System.out.println(obj);
}
}
}
使用通配符后数据的读取和写入要求
import org.junit.Test;
import java.util.AbstractList;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class GenericTest {
@Test
public void test3(){
List<Object> list1 = null;
List<String> list2 = null;
List<?> list = null;
list = list1;
list = list2;
List<String> list3 = new ArrayList<>();
list3.add("AA");
list3.add("BB");
list3.add("CC");
list = list3;
list.add(null);
Object o = list.get(0);
System.out.println(o);
}
}
有限制条件的通配符的使用
- 允许所有泛型的引用调用
- 通配符指定上限上限 extends：使用时指定的类型必须是继承某个类，或者实现某个接口，即
- 通配符指定下限 下限super：使用时指定的类型不能小于操作的类，即>=
- 举例：
- (无穷小, Number] 只允许泛型为Number及Number子类的引用调用
- [Number , 无穷大) 只允许泛型为Number及Number父类的引用调用
- 只允许泛型为实现Comparable接口的实现类的引用调用
- Person类
public class Person {
}
- Student类
public class Student extends Person{
}
- 测试类
import org.junit.Test;
import java.util.AbstractList;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class GenericTest {
@Test
public void test4(){
List<? extends Person> list1 = null;
List<? super Person> list2 = null;
List<Student> list3 = new ArrayList<Student>();
List<Person> list4 = new ArrayList<Person>();
List<Object> list5 = new ArrayList<Object>();
list1 = list3;
list1 = list4;
list2 = list4;
list2 = list5;
list1 = list3;
Person p = list1.get(0);
list2 = list4;
Object obj = list2.get(0);
list2.add(new Person());
list2.add(new Student());
}
}
泛型应用举例
泛型嵌套
public static void main(String[] args) {
HashMap<String, ArrayList<Citizen>> map= new HashMap<String, ArrayList<Citizen>>();
ArrayList<Citizen> list= new ArrayList<Citizen>();
list.add(new Citizen("刘恺威"));
list.add(new Citizen("杨幂"));
list.add(new Citizen("小糯米"));
map.put("刘恺威", list);
Set<Entry<String, ArrayList<Citizen>>> entrySet= map.entrySet();
Iterator<Entry<String, ArrayList<Citizen>>> iterator= entrySet.iterator();
while(iterator.hasNext()) {
Entry<String, ArrayList<Citizen>> entry= iterator.next();
String key= entry.getKey();
ArrayList<Citizen> value= entry.getValue();
System.out.println("户主："+ key);
System.out.println("家庭成员："+ value);
}
}
实际案例
interface Info{
}
class Contact implements Info{
private String address ;
private String telephone ;
private String zipcode ;
public Contact(String address,String telephone,String zipcode){
this.address = address;
this.telephone = telephone;
this.zipcode = zipcode;
}
public void setAddress(String address){
this.address = address ;
}
public void setTelephone(String telephone){
this.telephone = telephone ;
}
public void setZipcode(String zipcode){
this.zipcode = zipcode;
}
public String getAddress(){
return this.address ;
}
public String getTelephone(){
return this.telephone ;
}
public String getZipcode(){
return this.zipcode;
}
@Override
public String toString() {
return "Contact [address=" + address + ", telephone=" + telephone
+ ", zipcode=" + zipcode + "]";
}
}
class Introduction implements Info{
private String name ;
private String sex ;
private int age ;
public Introduction(String name,String sex,int age){
this.name = name;
this.sex = sex;
this.age = age;
}
public void setName(String name){
this.name = name ;
}
public void setSex(String sex){
this.sex = sex ;
}
public void setAge(int age){
this.age = age ;
}
public String getName(){
return this.name ;
}
public String getSex(){
return this.sex ;
}
public int getAge(){
return this.age ;
}
@Override
public String toString() {
return "Introduction [name=" + name + ", sex=" + sex + ", age=" + age
+ "]";
}
}
class Person<T extends Info>{
private T info ;
public Person(T info){
this.info = info;
}
public void setInfo(T info){
this.info = info ;
}
public T getInfo(){
return info ;
}
@Override
public String toString() {
return "Person [info=" + info + "]";
}
}
public class GenericPerson{
public static void main(String args[]){
Person<Contact> per = null ;
per = new Person<Contact>(new Contact("北京市","01088888888","102206")) ;
System.out.println(per);
Person<Introduction> per2 = null ;
per2 = new Person<Introduction>(new Introduction("李雷","男",24));
System.out.println(per2) ;
}
}
自定义泛型类练习
- 泛型类DAO
import java.util.*;
public class DAO<T> {
private Map<String,T> map = new HashMap<String,T>();
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(){
ArrayList<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);
}
}
- User类
public class User {
private int id;
private int age;
private String 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;
}
public User(int id, int age, String name) {
this.id = id;
this.age = age;
this.name = name;
}
public User() {
}
@Override
public String toString() {
return "User{" +
"id=" + id +
", age=" + age +
", name='" + name + '\'' +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
User user = (User) o;
if (id != user.id) return false;
if (age != user.age) return false;
return name != null ? name.equals(user.name) : user.name == null;
}
@Override
public int hashCode() {
int result = id;
result = 31 * result + age;
result = 31 * result + (name != null ? name.hashCode() : 0);
return result;
}
}
- 测试类
import java.util.List;
public class DAOTest {
public static void main(String[] args) {
DAO<User> dao = new DAO<User>();
dao.save("1001",new User(1001,34,"周杰伦"));
dao.save("1002",new User(1002,20,"昆凌"));
dao.save("1003",new User(1003,25,"蔡依林"));
dao.update("1003",new User(1003,30,"方文山"));
dao.delete("1002");
List<User> list = dao.list();
list.forEach(System.out::println);
}
}
整个Java全栈系列都是笔者自己敲的笔记。写作不易，如果可以，点个赞呗！✌
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
