十 泛型

泛型，可以理解为就是标签

集合容器类在设计声明阶段，不能明确其具体存储的类型，

JDK5之前元素类型只能设置成Object

JDK5之后引入泛型，此时在容器上使用参数确定容器中存储的类型

如Collection,List,ArrayList, 其中就是类型参数：即泛型

这样等真正使用时再给E赋值（传入参数）

10.1 集合中使用泛型

不用泛型

ArrayList list = new ArrayList();
list.add(1);
list.add(3);
list.add(5);

list.add("sdf");//全完正确，编译不会出问题，但是类型不安全，如果list用来存放成绩数据，则运行时可能异常
for(Object score：list){
    int stuScore = (Integer)score;//必须强转，因为score是Object类型的
}

使用泛型

泛型是个类型，不能是基本数据类型

ArrayList list = new ArrayList();//不能是int
list.add(1);
list.add("dsf");//报错了，编译时进行类型检查，保证了数据安全

//方式一
for(Integer score:list){
    int stuScore=score;//这里就不用强转了
}

//方式二
Iterator iter = list.iterator();
while(iter.hasNext()){
    sout(iter.next());
}

HashMap

Map amp = new HashMap<>();//JDK7之后new后面的<>就可以省略了：类型推断
map.put("sd",1);
map.put("sdf",2);

Set> entry = map.entrySet();

for(Entry en: entry){
    en.getkey();
    en.getValue();W
}
//or
Iterator> iter =entry.iterator();
while(iter.hasNext()){
    Map.Entry e = iter.next();
	e.getKey;
    e.getValue;
}

10.2 自定义泛型

10.2.1 泛型类，泛型接口

通常泛型字母的设置

K V 键值 T 类 E 方法

public class Order{
	String orderName;
    int orderId;
    T orderT;
    public Order(){}
    public Order(... , T orderT){
        this. ....
        this.orderT=orderT;
    }
    public T getOrderT(){
        return orderT;
    }
}

//实例化的时候如果没有指明泛型得类型，则默认为Object类型
Order o = new Order();//刚开始写不习惯，前面的<>特别容易忘记
Order o =new Order<>();

继承：

//继承时指明泛型
public class SubOrder extends Order{
    ....
}
SubOrder sub = new SubOrder("aa",1,"OrderT");

//继承时没有指明
public class SubOrder extends Order{
    E subOrderE;
    ...
}
SubOrder subOrder = new SubOrder<>();

class Fu{
}
class Z1 extends Fu{} // 相当于class Z1 extends Fu
class Z2 extends Fu{ } //指明了具体类型
class Z3 extends Fu{ }//全部保留
class Z4 extends Fu{ }//部分保留

一个类，实例化成了两种不同泛型的对象，彼此就没啥关系啦，不能相互赋值 （编译就过不了）

异常类不可以有泛型

静态成员方法的里不可以有泛型。简单的说就是从第一个p开始到最后一个}结束，就别有泛型的字母

普通成员方法的trycatch里面，也不行。

T[] arr =new T[10 ]; 不行！

T[] arr = (T[ ]) new Object[10];

10.2.2泛型方法

啥事泛型方法嘞？

不是说泛型里使用了类的泛型就叫泛型方法，

//这不是泛型方法
int add(E e);
public List copyXxxx(E[] arr){//编译器会把E[]认为是个某个声明的类型的数组 

//这才是
 T[ ] toArray(T[ ] a); 

public  List copyXxxx(E[] arr){ 
}
//方法使用
List list = Order.copyXxxx(new Integer(){1,2,3});//传入的参数决定了E的类型

泛型方法可以使静态的！！！！

因为泛型参数是在调用时确定的，而不需要类的初始化

但是要区分泛型方法的泛型 和 方法里类的泛型

10.2.3 例子：DAO类

data(base) access object

问题，表很多，各种类型的，每个类型每个数据都写增删改查太麻烦了。所以用泛型

做法：让数据库中的每个表对应java中的一个类，操作每个表对应操作类的对象,到底对应的那个类呢？？ 对应T

public class DAO{
    //增
    public void add(T t){
        ...
    }
    //删
    public boolean remove(int index){...}
    //改
    public void update(int index,T t){...}
    //查
    public T getIndex(int index){return null}
    pubcli List getFullIndex(int begin,int end){return null}
    
    //泛型方法
    public  E getValue(){ //举例：获取表中一共有多少条记录：E赋值为整型Long
        //又举例：获取全部员工工资，E赋值为浮点型
        return null;
    }
}

//顾客表
public class Customer{
    String name;
    ...
}
public class customerDAO extens DAO{
        //空的，啥也不写
}
//学生表
public class Student{
    ...
}
public class StudentDAO extends DAO{//每个XxxxDAO只能操作对应的表
}

//测试
public class DAOTest{
	@Test
    public void test1(){
        CustomerDAO dao1 =new CustomerDAO();
        dao.add(new Customer());
        List list = dao.getFullIndex(10,13);
    }
    
    @Test
    public void test2(){
        StudentDAO dao =new STudentDAO();
        dao.add(...);
    }
}

10.3 泛型 继承

List