泛型（Generic）

概念

泛型类似于标签 表示类型

JDK 5.0新特性，集合类全部修改为带泛型结构，泛型不能是基本数据类型，可以使用包装类

允许类、接口通过一个标识表示整体的元素类型或某个方法的参数类型，即在添加元素时限制类型，比Object更严格，类似垃圾回收，原本垃圾桶不分类，后来垃圾桶进行分类，垃圾按照垃圾桶的标签进行放置，当未声明泛型类型时默认使用Object

//没有泛型之前，由于Object编译时没有类型检查，类型不安全，例如当前场景是成绩存储，遍历或接受时以int类型接收，出现错误
ArrayList arrayList = new ArrayList();
arrayList.add(12);
arrayList.add(34);
arrayList.add("AA");
arrayList.add(78);

for(Object obj :arrayList){
        int num = (Integer) obj;
        System.out.println(num);//ClassCastException报异常
        }

     //编译时会进行类型检查，提示错误，保障数据安全
        ArrayList<Integer> arrayList = new ArrayList<Integer>();
        arrayList.add(12);
        arrayList.add(34);
//        arrayList.add("AA");
        arrayList.add(78);

        for (Integer obj : arrayList) {
            //避免强转操作
            int num = obj;
            System.out.println(num);
        }

//HashMap<String, Integer> hashMap = new HashMap<String, Integer>();
//JDK 7.0新特性类型推断，后面可省略泛型标签
HashMap<String, Integer> hashMap = new HashMap<>();

hashMap.put("A",1);
hashMap.put("B",2);

//泛型的嵌套
Set<Map.Entry<String, Integer>> entries = hashMap.entrySet();
Iterator<Map.Entry<String, Integer>> iterator = entries.iterator();
while (iterator.hasNext()){
   Map.Entry<String,Integer>  entry = iterator.next();
    String key = entry.getKey();
    Integer value = entry.getValue();
    System.out.println("keyIs:"+key+"-->valueIs:"+value);
}

自定义泛型结构

• 泛型类

package xyz.tylt.learn.test;

public class Test<T> {

    String name;
    int age;
    //未声明参数类型
    T test;


    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public T getTest() {
        return test;
    }

    public void setTest(T test) {
        this.test = test;
    }



    public Test() {
    }

    public Test(String name, int age, T test) {
        this.name = name;
        this.age = age;
        this.test = test;
    }

    public static void main(String[] args) {
        //泛型标签类型只影响定义成泛型的成员变量
        Test<Integer> test =  new Test<>();
        test.setTest(123);
        test.setName("AA");
        System.out.println(test.getTest()+" "+ test.getName());

    }
}

package xyz.tylt.learn.test;
//在此处指明继承泛型父类的变量类型，也可以是TestSon<T> extends Test<T>，这样子类仍然是泛型类
public class TestSon extends Test<Integer>{


    /*
     * 子类集成泛型父类，子类设定时具有泛型标签属性，但是子类不再是泛型类
     **/

    public static void main(String[] args) {

        TestSon testSon = new TestSon();
        testSon.setTest(123);
    }


}

//多个泛型参数情况
public class Test<T, E, U> {

    T testName;
    E testAge;
    U testPassword;


}

异常类不能声明为泛型类

• 泛型接口
  略···

• 泛型方法

所属的类或接口是否为泛型不影响

package xyz.tylt.learn.test;

import java.util.ArrayList;
import java.util.List;

//多个泛型参数情况
public class Test {


    public <E> List<E> show(E[] arr) {
        ArrayList<E> list = new ArrayList<>();

        for (E e : arr) {
            list.add(e);
        }
        return list;
    }

    public static void main(String[] args) {
        Test test = new Test();
        String[] str = {"A","B","C"};
        System.out.println(test.show(str));

    }


}

情景使用

//编写JavaBean

public class Persion {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Persion() {
    }

    public Persion(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Persion{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

package xyz.tylt.learn.test;


import java.util.List;

/*
 * 泛型的具体使用情景
 * 用于数据交互层，操作表的共性操作
 **/
public class Dao<T> {

    //增加一条数据
    public boolean insert(T t){
        return true;
    }

    //删除一条数据
    public boolean deleteOne(int id){
        return true;
    }

    //修改一条数据
    public boolean updateOne(T t){
        return true;
    }

    //查询一条数据
    public List<T> selectOne(int index){
        return null;
    }

}

/*
 * 继承原始Dao并重写方法
 * 测试
 */
public class PersionDao extends Dao<Persion>{

     public static void main(String[] args) {
        PersionDao persionDao = new PersionDao();
        Persion persion = new Persion();
        persion.setName("A");
        persion.setAge(10);

        boolean insert = persionDao.insert(persion);
        System.out.println(insert);

    }
    
}