写点什么

Java 新特性之泛型,kafka 的架构图

用户头像
极客good
关注
发布于: 刚刚

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 自定义泛型类、接口




  1. 泛型类可能有多个参数,此时应将多个参数一起放在尖括号内 。比如:<E1,E2,E3>;

  2. 泛 型类的构造器为 public GenericClass(){} ,而非public GenericClass<E>(){}

  3. T 不能用基本数据类型填充,但可以使用包装类填充;

  4. 静态方法中不能使用类的泛型;

  5. 异常类是不能泛型的;

  6. 不能使用 new E[] ;但是可以 E [] elements = (E[])new Object[capacity];

  7. 父类有泛型,子类可以选择保留泛型也可以选择指定泛型类型。


/**


  • 自定义泛型类

  • <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 类


【一线大厂Java面试题解析+核心总结学习笔记+最新架构讲解视频+实战项目源码讲义】
浏览器打开:qq.cn.hn/FTf 免费领取
复制代码


/**


  • 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<?>。其中的?在泛型中便是通配符。

用户头像

极客good

关注

还未添加个人签名 2021.03.18 加入

还未添加个人简介

评论

发布
暂无评论
Java 新特性之泛型,kafka的架构图