不是太细的java自学笔记进阶篇6（p548-576）（Map补充内容，泛型，自定义泛型，通配符，有限制的通配符）

目录：

Map补充：

遍历：

负载因子：

LinkedHashMap：

泛型：标签

泛型概念

自定义泛型

DAO层

通配符

有限制的通配符

举例（重要）：

---

 

这部分的代码在javalearn->com.lzy.genericlearn中：

GIthub指路：这里

 

Map补充：

遍历：

  

负载因子：

 

LinkedHashMap：

 

 

泛型：标签

泛型概念

感觉就是和C++中的模板一样。

  

在使用泛型的时候，不能使用基本类型，而是要使用其包装类。

 

自定义泛型

   

泛型方法：在方法中出现了泛型的结构，但是泛型参数要和类的泛型没哟佮关系。

泛型方法：可以声明为静态的，因为：泛型参数是在调用方法时确定的，而不是在实例化类时确定的。

/***********

注意了，假如一个泛型类的泛型为T，其方法（其中也有泛型）是不可以声明为静态的，因为静态方法在编译的时候就需要确定，但是泛型只有在实例化的时候才能确定，所以会出现编译错误。（例如下）

 

但是泛型方法，也就是在泛型类中的一个泛型方法，其泛型为E，是可以声明为静态的。因为泛型方法在使用时我们需要直接确定E的类型，这样可以编译通过。（例如下图）

**********/

 

需要在public 后面指定<E>.这个语法表明后面的E不是一个类型而是一个泛型。

DAO层

java的一个具体的类，用来操作数据库的增删改查方法，进行数据操作。之后根据每一个特殊的类进行继承。

  

通配符

破坏了多态的特性：增加了需要重载的方法。

  

有限制的通配符

 

举例（重要）：

package com.lzy.genericlearn;

import org.junit.Test;

import java.util.List;

/**
 * @author: lzy
 * @description: 通配符的使用
 * @date: 2020-09-20-12:13
 */
public class TongPeiFu {

    @Test
    public void test1(){
        List<Object> list1=null;
        List<String> list2=null;
        List<?> list3=null;
        list3=list1;
        list3=list2;

        show(list1);
        show(list2);

    }

    @Test
    public void test2(){
        List<? extends Person> list1=null;
        List<? super Person> list2=null;

        List<Student> list3=null;
        List<Person> list4=null;
        List<Object> list5=null;

        //得出extends表示小于等于这个类，所以承接需要使用到Person类，相当于(-无穷，Person]
        //写入数据不能写入Student类型的数据，子类可以赋给父类，反之不行。所以如果给了更小类型就会出错。
        list1=list3;
        list1=list4;
        //list1=list5;
        //list1.add(new Student());

        //得出super表示大于等于这个类，所以承接需要使用顶级的父类Object,相当于[Person,+无穷）
        //这个时候只要小于等于Person类就可以，根据区间可知父类类型肯定大于等于Person这个类。
        //list2=list3;
        list2=list4;
        list2=list5;
        list2.add(new Person());
        list2.add(new Student());
    }

    public void show(List<?> list){
        /*Iterator<?> iterator = list.iterator();
        while (iterator.hasNext()){
            Object obj=iterator.next();
            System.out.println(obj);
        }*/

        System.out.println("***");
    }

}

 

package com.lzy.genericlearn;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Map;

/**
 * @author: lzy
 * @description: 自定义泛型的类
 * @date: 2020-09-20-14:49
 */
public class DAOTest<T> {
    private Map<String,T> map;

    public Map<String, T> getMap() {
        return map;
    }

    public void setMap(Map<String, T> map) {
        this.map = map;
    }

    public void save(String id, T th){
        map.put(id,th);
    }

    public List<T> list(){

        //错误的,map无序，但是List有序。
        //强转需要首先这个数据是这个类型本身然后在转换回来。
        /*Collection<T> values=map.values();
        return (List<T>) values;*/
        //正确的
        ArrayList<T> list=new ArrayList<>();
        Collection<T> values=map.values();
        for(T t : values){
            list.add(t);
        }
        return list;
    }
}