泛型

泛型Generic（JDK1.5新加入）：

1、在 Java 中以 "<>" 的形式呈现，"<>" 中写引用数据类型

2、泛型中的类型可用任意字母代表
通常我们使用 T : Type E : Element K : Key V : Value R : Return

为什么使用泛型：

1、我们在操作数据时，有时不知道要操作的数据是什么类型。
提高代码复用性
2、集合中不使用泛型，意味着集合中可以存储任意类型的对象
若需要具体到某一个数据类型时，需要强制类型转换，可能引发 ClassCastException
解决元素存储的安全性, 解决获取元素时，需要类型强转的问题（繁琐）

泛型本质

只作编译时限制，当执行时不作读取。
证：通过查看.class文件，<>是不存在的

泛型相关使用

集合中

1、List
List<String> list=new ArrayList<>();
①add() 只能添加String
②泛型提供编译检查

---

2、迭代器使用泛型
Iterator<Integer> it=set.iterator();
当遍历时，迭代器使用泛型或者Map遍历使用泛型，等于取出的类型也限制

---

3、Map
Set<Entry<Person,Integer>> set=map.entrySet();
Iterator<Entry<Person,Integer>> it=set.iterator();
while(it.hasNext()){
Entry<Person,Integer> ety=it.next();
Person p=ety.getKey();
Integer ity=ety.getValue();
System.out.println(p+"=="+ity);
}

DAO层

1、场景
数据库表，属性<——>类，属性
成千上万张表——>成千上万个类处理
处理方法——>成千上万的方法

2、我们想要的方法是：当千万张表使用同一个功能方法时，我们只写一个这样的方法即可

3、这时，设计带泛型的DAO类，适用于任意不同类型的类

    public class DAO<T> {//Database Access Object
        
        private List<T> list = new ArrayList<>();
        
        public void add(T t){
            list.add(t);
        }
        
        public T get(int id){
            return list.get(id);
        }
        
        public void update(int id, T t){
            list.set(id, t);
        }
    }

    //对任意不同类型的类进行操作
    public void test5(){
        DAO<Person> dao = new DAO<>();
        dao.add(new Person("张三", 18));
        Person p = dao.get(0);
        System.out.println(p);
        
        DAO<Order> orderDAO = new DAO<>();
        orderDAO.add(new Order());
        Order o = orderDAO.get(0);
        System.out.println(o);
    }

自定义泛型类、接口

1、何时定义：
当我们在写时不确定以后要用的是什么类型，但知道肯定要有这个元素

2、何时确定？ 使用时确定

3、示例

    public class MyGeneric <T>{
    private T tt;//未知类型
    
    public void add(T tt){ //不确定类型
        
    }
    
    public T get(){ //不确定类型
        return null;
    }

     @Test
    public void test4(){
        //使用时，类型随着类类型的确定而确定，有了编译检查，其他类型不可传递
        MyGeneric<String> mg = new MyGeneric<>();
        mg.add("BBB"); 
        String str=mg.get();
        
        MyGeneric<Person> mg1 = new MyGeneric<>();//使用该类
        mg1.add(new Person());
        Person p=mg1.get();
    }

自定义泛型方法

1、何时定义：
当写方法时，返回值不确定
同时，返回值的类型与类的<T>又不一样

2、如何定义：在方法中声明<>

3、方法在什么时候可以确定类型？（参数列表）
调用方法，传入一个实参时，返回值的类型以实参的类型为准

4、示例

    public <E> E sort(List<E> list){
            //sort(new ArrayList<String>());
        return list.get(0);
    }

通配符 ( ? )

1、为何使用？
虽然 Man 是 Person 的子类，但是泛型限制后 List<Man> 就不能给List<Person> 。
意味着不能使用多态

2、统配符的三种使用
List<?> :
1 可以接收任意泛型类型的集合
2 但是在集合的使用中，遍历时又的按Object取！要强转！又倒回去了！

List<? extends Person> :
1 只可以接收 Person 本类类型的泛型集合及 Person 子类类型的泛型集合，再次限制类型为Person
2 我们又可以使用多态了
3 若要调用子类特有方法，当然还得 instanceof

List<? super Person> :
1 只可以接收 Person 本类类型的泛型集合集 Person 父类类型的泛型集合
2 向上限制，没啥用