=======================================================================
所谓泛型(Generic),就是允许在定义类、接口时通过一个标识来 表示 类中某个属性的类型或者是某个方法的返回值及参数类型。
这个类型参数将在使用时确定。例如当继承或者实现某个接口时,通过在声明或者创建对象时,传入实际的类型参数来确定。
我们用在集合中添加元素举例。
当集合中没有泛型时:
/**
-
需求:存放学生的成绩
-
1 当集合中不使用泛型时。集合中的任何元素都会默认用 Object 来对待
*/
@Test
public void test1(){
ArrayList list = new ArrayList();
list.add(78);
list.add(76);
list.add(89);
list.add(88);
//问题一:类型不安全
list.add(“Tom”);
for(Object score : list){
//问题二:强转时,可能出现ClassCastException
int stuScore = (Integer) score;
System.out.println(stuScore);
}
}
当集合中使用泛型时:
/**
-
需求:存放学生的成绩
-
2 在集合中使用泛型的情况:以ArrayList为例
*/
@Test
public void test2(){
ArrayList list = new ArrayList();
list.add(78);
list.add(87);
list.add(99);
list.add(65);
//编译时,就会进行类型检查,保证数据的安全。因为在实例化时规定了泛型是Integer
//型,所以list中无法加入String类型的"Tom"
//list.add(“Tom”);
//方式一:
// for(Integer score : list){
// //避免了强转操作
// int stuScore = score;
//
// System.out.println(stuScore);
//
// }
//方式二:
Iterator iterator = list.iterator();
while(iterator.hasNext()){
int stuScore = iterator.next();
System.out.println(stuScore);
}
}
重点:
-
泛型只能使用包装数据类型,而不能使用基本数据类型;
-
如果实例化时,没指明泛型的类型。默认类型为 java.lang.Object 类型;
-
把一 个集合中的内容限制为一个特定的数据类型,这就是泛型背后的核心思想;
-
泛型在实例化之后,后面的集合就一定要放实例化时固定的类型了。
==============================================================================
/**
-
需求:存放学生的成绩
-
1 在集合中使用泛型的情况:以ArrayList为例
*/
@Test
public void test2(){
// 如果没有,那么就表示ArrayList中变量类型是 Object 类型的。
ArrayList list = new ArrayList<>();
list.add(78);
list.add(87);
list.add(99);
list.add(65);
Iterator 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);
}
}
============================================================================
-
泛型类可能有多个参数,此时应将多个参数一起放在尖括号内 。比如:<E1,E2,E3>;
-
泛 型类的构造器为
public GenericClass(){}
,而非public GenericClass<E>(){}
; -
T 不能用基本数据类型填充,但可以使用包装类填充;
-
静态方法中不能使用类的泛型;
-
异常类是不能泛型的;
-
不能使用
new E[]
;但是可以E [] elements = (E[])new Object[capacity]
; -
父类有泛型,子类可以选择保留泛型也可以选择指定泛型类型。
/**
-
自定义泛型类
-
- 中的 T 表示的是什么类型;
-
- 泛型类并不是表示这个类是什么类型,而是表示类中的属性是什么类型,且这些类型在构造对象的时候确定;
-
- 类名中的 是为了声明这个类是泛型类。
*/
public class Order {
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);
// }
}
public class Order {
String orderName;
int orderId;
T order;
public Order(){
T[] arr = (T[]) new Object[10];
}
//泛型方法:在方法中出现了泛型的结构,泛型参数与类的泛型参数没有任何关系。
// 换句话说,泛型方法所属的类是不是泛型类都没有关系。
//泛型方法是可以声明为静态的,原因是泛型方法的泛型参数是在调用方法时确定的,并非在实例化类时确定。
public static List copyFromArrayToList(E[] arr){
ArrayList list = new ArrayList<>();
for(E e : arr){
list.add(e);
}
return list;
}
}
在 Java 对数据库的操作中,我们常采用 ORM 思想,即数据库中的一张表对应一个 JavaBean 对象。
基本思想:对于不同表的很多操作都是相同的,这些操作,唯一不同的是被操作的对象。所以我们可以定义一个 DAO.java
来定义操作数据库中的表的通用操作,然后利用泛型来约定不同的对象。
1)定义基本操作的Dao类
/**
- DAO:data(base) access object
*/
public class DAO {//表的共性操作的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 getForList(int index){
return null;
}
//泛型方法
//举例:获取表中一共有多少条记录?获取最大的员工入职时间?
public 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{
}
5)操作 students 表的 DAO
/**
- 只能操作 students 表的 DAO
*/
public class StudentDAO extends DAO {
}
6)测试类
public class DAOTest {
@Test
public void test1(){
//对 customs 表进行操作
CustomerDAO dao1 = new CustomerDAO();
dao1.add(new Customer());
List list = dao1.getForList(10);
//对 students 表进行操作
StudentDAO dao2 = new StudentDAO();
Student student = dao2.getIndex(1);
}
}
如果没有多态的话,我们需要写很多重载的方法。这是一个重点。
==============================================================================
现在有三个类,分别为类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 list1 = null;
List list2 = new ArrayList();
//编译不通过,此时的list1和list2的类型不具有子父类关系
//list1 = list2;
}
/**
A<G>
是B<G>
的父类。所以可以赋值。
*/
@Test
public void test2(){
AbstractList list1 = null;
List list2 = null;
ArrayList list3 = null;
list1 = list3;
list2 = list3;
List list4 = new ArrayList<>()
}
===========================================================================
由第四章可知,尽管类A是类B的父类,但是G<A>
和G<B>
是没关系的,不过二者共同的父类是:G<?>
。其中的?
在泛型中便是通配符。
?
在数据库中叫做占位符。
@Test
public void test3(){
List list1 = null;