泛型和DAO设计

1、基本概念
class ArrayList
<>: typeof,元素是什么类型的
E：泛型的形式参数类型
：泛型的实际参数类型
ArrayList：带有泛型的类型
ArrayList:参数化的泛型类型（ParameterizedType）

2、泛型的正确写法
ArrayList list = new ArrayList(); X
ArrayList list = new ArrayList(); X
ArrayList list = new ArrayList (); 正确
ArrayList list = new ArrayList(); 正确

使用：两边都带有泛型的，泛型的类型必须完全一致。可以只有一边有。

3.泛型的通配符：
上限：List<? extend Number> :?号类型必须是Number的子类
下限：List<? super Integer> :？号类型必须是Interger的父类

//泛型方法的定义
public class GenericDemo1 {
    //<T>:声明泛型。必须放在方法的返回值的前面
    //泛型只有声明后才能使用
    public <T> T m1(){
        return null;
    }
    public <T> void m2(T t){

    }
    public static <T> T m3(){
        return null;
    }
}

//泛型类的定义:GenericDemo2<T>
//类上定义的泛型，实例方法上就可以直接使用了
//静态方法都必须先定义后使用
public class GenericDemo2<T> {

    public T m1(){
        return null;
    }
    public void m2(T t){

    }
    public static <T> T m3(){
        return null;
    }
}

//定义多个泛型类型
public class GenericDemo3 {

    public static <K,V> V m3(K k){//Map
        return null;
    }
}

public class ArrayUtil {
    //实现任意数组指定位置上元素的交换(1 2 3 4            0 3-->4 2 3 1)
    public static <T> void change(T[] t,int index1,int index2){
        T tmp = t[index1];
        t[index1] = t[index2];
        t[index2] = tmp;
    } 
    //翻转数组中的元素（1 2 3 4 ---》4 3 2 1）
    public static <T> void reverse(T[] t){

        int startIndex = 0;
        int endIndex = t.length-1;

        while(startIndex<endIndex){
            T tmp = t[startIndex];
            t[startIndex] = t[endIndex];
            t[endIndex] = tmp;
            startIndex++;
            endIndex--;
        }
    }
}

@Test
    public void testChange() {
        Integer i[] = {1,2,3,4,5,6};
        ArrayUtil.change(i, 1, 4);
        System.out.println(Arrays.asList(i));
    }
    @Test
    public void testReverse(){
        Integer i[] = {1,2,3,4,5};
        ArrayUtil.reverse(i);
        System.out.println(Arrays.asList(i));
    }

DAO设计

public interface Dao<T> {
    void add(T t);
    void update(T t);
    void delete(Serializable id);
    //Serializable：可以接收更多的类型
    // String Integer 更加通用。多个参数使用联合主键类传入
    T findOne(Serializable id);
}

//联合主键时，封装成类
public class name implement Seriallizable{
    String fistName;
    String id;
}

public interface CustomerDao extends Dao<Customer>{
    List<Customer> find();
}

//借助Hibernate框架
public class BaseDao<T> implements Dao<T> {
    private Session session;//核心类。Connection
                        //ORM:通过操作类，就相当于操作了数据库
                        //比如：操作Customer类，就相当于存取Customer表（Hibernate来做）
                        //操作Student类，就相当于存取Student表（Hibernate来做）

    private Class clazz;//实体类型，目的就是让Hibernate知道从哪个表中查数据
    public BaseDao(){
        //给成员变量clazz赋值，让BaseDao知道具体的操作的是什么类型的
//      System.out.println(this);// com.itheima.dao.impl.CustomerDaoImpl@5d888759
        Type type = this.getClass().getGenericSuperclass();//获取当前对象的带有泛型类型的父类  BaseDao<Customer>
        ParameterizedType ptype = (ParameterizedType)type;
        clazz = (Class)ptype.getActualTypeArguments()[0];
    }

    public void add(T t) {
        session.save(t);
    }

    public void update(T t) {
        session.update(t);
    }

    public void delete(Serializable id) {
        T t = findOne(id);
        session.delete(t);
    }

    public T findOne(Serializable id) {
        System.out.println(clazz.getName());
        return (T)session.get(clazz, id);//第一个参数：操作的类的类型。第二个参数，主键
    }

}

public class CustomerDaoImpl extends BaseDao<Customer> implements CustomerDao {
//  public CustomerDaoImpl(){
//      super();
//  }
    public List<Customer> find() {
        return null;
    }

}

public static void main(String[] args) {
        cDao.findOne(1);
        CustomerDao cDao = new CustomerDaoImpl();
    }