Java 新特性之泛型，kafka 的架构图
public void test2(){
// 如果没有<Integer>,那么就表示 ArrayList 中变量类型是 Object 类型的。
ArrayList<Integer> list = new ArrayList<>();
list.add(78);
list.add(87);
list.add(99);
list.add(65);
Iterator<Integer> iterator = list.iterator();
while(iterator.hasNext()){
int stuScore = iterator.next();
System.out.println(stuScore);
}
}
/**
需求：存放学生的成绩
2 在集合中使用泛型的情况：以 HashMap 为例
*/
@Test
public void test3(){
Map<String,Integer> map = new HashMap<>();
map.put("Tom",87);
map.put("Jerry",87);
map.put("Jack",67);
//泛型的嵌套
Set<Map.Entry<String,Integer>> entry = map.entrySet();
for (Map.Entry<String, Integer> e : entry) {
String key = e.getKey();
Integer value = e.getValue();
System.out.println(key + "----" + value);
}
}
[](
)3 自定义泛型结构
============================================================================
[](
)3.1 自定义泛型类、接口
泛型类可能有多个参数，此时应将多个参数一起放在尖括号内 。比如：<E1,E2,E3>；
泛 型类的构造器为
public GenericClass(){}，而非public GenericClass<E>(){}；T 不能用基本数据类型填充，但可以使用包装类填充；
静态方法中不能使用类的泛型；
异常类是不能泛型的；
不能使用
new E[]；但是可以E [] elements = (E[])new Object[capacity];父类有泛型，子类可以选择保留泛型也可以选择指定泛型类型。
/**
自定义泛型类
<T>中的 T 表示的是什么类型；
泛型类并不是表示这个类是什么类型，而是表示类中的属性是什么类型，且这些类型在构造对象的时候确定；
类名中的 <T> 是为了声明这个类是泛型类。
*/
public class Order<T> {
String orderName;
int orderId;
//类的内部结构就可以使用类的泛型
T order;
public Order(){
// 在构造函数中必须使用下面一种方法
// T[] arr = new T[10];
T[] arr = (T[]) new Object[10];
}
public Order(String orderName,int orderId,T order){
this.orderName = orderName;
this.orderId = orderId;
this.order = order;
}
//如下的三个方法都不是泛型方法
public T getOrder(){
return order;
}
public void setOrder(T order){
this.order = order;
}
@Override
public String toString() {
return "Order{" +
"orderName='" + orderName + ''' +
", orderId=" + orderId +
", order=" + order +
'}';
}
//静态方法中不能使用类的泛型，因为泛型的创建是在类的实例化时，而静态方法是属于类本身的。
// public static void show(T order){
// System.out.println(order);
// }
}
[](
)3.2 自定义泛型方法
public class Order<T> {
String orderName;
int orderId;
T order;
public Order(){
T[] arr = (T[]) new Object[10];
}
//泛型方法：在方法中出现了泛型的结构，泛型参数与类的泛型参数没有任何关系。
// 换句话说，泛型方法所属的类是不是泛型类都没有关系。
//泛型方法是可以声明为静态的，原因是泛型方法的泛型参数是在调用方法时确定的，并非在实例化类时确定。
public static <E> List<E> copyFromArrayToList(E[] arr){
ArrayList<E> list = new ArrayList<>();
for(E e : arr){
list.add(e);
}
return list;
}
}
[](
)3.3 自定义泛型在数据库上的使用
在 Java 对数据库的操作中，我们常采用 ORM 思想，即数据库中的一张表对应一个 JavaBean 对象。
基本思想：对于不同表的很多操作都是相同的，这些操作，唯一不同的是被操作的对象。所以我们可以定义一个 DAO.java 来定义操作数据库中的表的通用操作，然后利用泛型来约定不同的对象。
1）定义基本操作的 Dao 类
/**
DAO:data(base) access object
*/
public class DAO<T> {//表的共性操作的 DAO
//添加一条记录
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;
}
}
2）数据库中的某一张表的 JavaBean 对象
/**
此类对应数据库中的 customers 表
*/
public class Customer {
}
3）数据库中的另一张表的 JavaBean 对象
/**
此类对应数据库中的 students 表
*/
public class Student {
}
4）操作 customs 表的 DAO
/**
只能操作 customs 表的 DAO
*/
public class CustomerDAO extends DAO<Customer>{
}
5）操作 students 表的 DAO
/**
只能操作 students 表的 DAO
*/
public class StudentDAO extends DAO<Student> {
}
6）测试类
public class DAOTest {
@Test
public void test1(){
//对 customs 表进行操作
CustomerDAO dao1 = new CustomerDAO();
dao1.add(new Customer());
List<Customer> list = dao1.getForList(10);
//对 students 表进行操作
StudentDAO dao2 = new StudentDAO();
Student student = dao2.getIndex(1);
}
}
如果没有多态的话，我们需要写很多重载的方法。这是一个重点。
[](
)4 泛型在继承上的体现
==============================================================================
现在有三个类，分别为类 A、类 B 和类 G，其中类 A 为类 B 的父类，那么：
G<A>和G <B>二者不是子父类关系，二者是并列关系；但是
A<G>是B<G>的父类。
代码说明：
/**
G<A>和G <B>二者不是子父类关系，二者是并列关系；所以不能赋值。
*/
@Test
public void test1(){
//多态的体现
Object obj = null;
String str = null;
obj = str;
Object[] arr1 = null;
String[] arr2 = null;
arr1 = arr2;
// 编译不通过，因为 String 并不是 Data 的父类。
//Date date = new Date();
//str = date;
List<Object> list1 = null;
List<String> list2 = new ArrayList<String>();
//编译不通过，此时的 list1 和 list2 的类型不具有子父类关系
//list1 = list2;
}
/**
A<G>是B<G>的父类。所以可以赋值。
*/
@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<>()
}
[](
)5 通配符的使用
===========================================================================
由第四章可知，尽管类 A 是类 B 的父类，但是G<A>和G<B>是没关系的，不过二者共同的父类是：G<?>。其中的?在泛型中便是通配符。
还未添加个人签名 2021.03.18 加入
还未添加个人简介
评论