@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. 在集合中使用泛型的例子1
//在集合中使用泛型，以ArrayList为例
@Test
public void test1(){
ArrayList list = new ArrayList<>();
list.add("AAA");
list.add("BBB");
list.add("FFF");
list.add("EEE");
list.add("CCC");
//遍历方式一：
Iterator iterator = list.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
System.out.println("-------------");
//便利方式二：
for (String str:
list) {
System.out.println(str);
}
}
图示：
3. 在集合中使用泛型例子2
@Test
//在集合中使用泛型的情况：以HashMap为例
public void test2(){
Map map = new HashMap<>();//jdk7新特性：类型推断
map.put("Tom",26);
map.put("Jarry",30);
map.put("Bruce",28);
map.put("Davie",60);
//嵌套循环
Set> entries = map.entrySet();
Iterator> iterator = entries.iterator();
while (iterator.hasNext()){
Map.Entry entry = iterator.next();
String key = entry.getKey();
Integer value = entry.getValue();
System.out.println(key+"="+value);
}
}
4. 集合中使用泛型总结：
① 集合接口或集合类在JDK 5.0时都修改为带泛型的结构。
② 在实例化集合类时，可以指明具体的泛型类型
③ 指明完以后，在集合类或接口中凡是定义类或接口时，内部结构（比如：方法、构造器、属性等）使用到类的泛型的位置，都指定为实例化的泛型类型。
比如：add(E e) --->实例化以后：add(Integer e)
④ 注意点：泛型的类型必须是类，不能是基本数据类型。需要用到基本数据类型的位置，拿包装类替换
⑤ 如果实例化时，没有指明泛型的类型。默认类型为java.lang.Object类型。
三、自定义泛型结构
泛型类、泛型接口、泛型方法
1. 泛型的声明
interface List 和 class GenTest其中，T，K，V，不代表值，而是表示类型。这里使用任意字母都可以。
常用T表示，是Type的缩写。
2. 泛型的实例化：
一定要在类名后面指定类型参数的值（类型）。如：
List strList =new ArrayList();
Iterator iterator = customers.iterator();
T只能是类，不能用基本数据类型填充。但可以使用包装类填充
把一个集合中的内容限制为一个特定的数据类型，这就是 generics背后的核心思想
//JDK 5.0以前
Comparable c = new Date();
System.out.println(c.comparaTo("red");
//JDK 5.0以后
Comparable c = new Date();
System.out.println(c.comparaTo("red");
class Father {
}
/**
* 定义泛型子类Son
* 情况一：继承泛型父类后不保留父类的泛型
*/
//1.没有指明类型 擦除
class Son1 extends Father {//等价于class Son1 extends Father{}
}
//2.指定具体类型
class Son2 extends Father {
}
/**
* 定义泛型子类Son
* 情况二：继承泛型父类后保留泛型类型
*/
//1.全部保留
class Son3 extends Father {
}
//2.部分保留
class Son4 extends Father{
}
4. 自定义泛型结构
4.1自定义泛型类
代码示例：
/**
* 自定义泛型类Order
*/
class Order {
private String orderName;
private int orderId;
//使用T类型定义变量
private T orderT;
public Order() {
}
//使用T类型定义构造器
public Order(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 static void show(T orderT){
// System.out.println(orderT);
// }
// //try-catch中不能是泛型的。
// public void show(){
// try {
//
// }catch (T t){
//
// }
// }
//泛型方法：在方法中出现了泛型的结构，泛型参数与类的泛型参数没有任何关系。
//换句话说，泛型方法所属的类是不是泛型类都没有关系。
//泛型方法，可以声明为静态的。
// 原因：泛型参数是在调用方法时确定的。并非在实例化类时确定。
public static List copyFromArryToList(E[] arr) {
ArrayList list = new ArrayList<>();
for (E e :
list) {
list.add(e);
}
return list;
}
}
自定义泛型类Order的使用
@Test
public void test1() {
//如果定义了泛型类，实例化没有指明类的泛型，则认为此泛型类型为Object类型
//要求：如果大家定义了类是带泛型的，建议在实例化时要指明类的泛型。
Order order = new Order();
order.setOrderT(123);
System.out.println(order.getOrderT());
order.setOrderT("abc");
System.out.println(order.getOrderT());
//建议：实例化时指明类的泛型
Order order1 = new Order<>("Tom", 16, "male");
order1.setOrderT("AA:BBB");
System.out.println(order1.getOrderT());
}
@Test
//调用泛型方法
public void test2(){
Order order = new Order<>();
Integer [] arr = new Integer[]{1,2,3,4,5,6};
List list = order.copyFromArryToList(arr);
System.out.println(list);
}
4.2自定义泛型接口
代码示例：
/**
* 自定义泛型接口
*/
public interface DemoInterface {
void show();
int size();
}
//实现泛型接口
public class Demo implements DemoInterface {
@Override
public void show() {
System.out.println("hello");
}
@Override
public int size() {
return 0;
}
}
@Test
//测试泛型接口
public void test3(){
Demo demo = new Demo();
demo.show();
}
//泛型方法：在方法中出现了泛型的结构，泛型参数与类的泛型参数没有任何关系。
//换句话说，泛型方法所属的类是不是泛型类都没有关系。
//泛型方法，可以声明为静态的。
// 原因：泛型参数是在调用方法时确定的。并非在实例化类时确定。
public static List copyFromArryToList(E[] arr) {
ArrayList list = new ArrayList<>();
for (E e :
list) {
list.add(e);
}
return list;
}
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;
}
}
【CustomerDAO.java】:
public class CustomerDAO extends DAO{//只能操作某一个表的DAO
}
【StudentDAO.java】:
public class StudentDAO extends DAO {//只能操作某一个表的DAO
}
