Java基础【泛型generic】

1、解决的问题

        类型安全问题。当不使用泛型时，会造成任意类型的数据都可以存储到集合中，当取出元素时，会涉及到造型的问题，比较繁琐。

2、自定义泛型类

package com.hike.javase.generic;

import org.junit.Test;

class person<T>{    //T表示某种类型，T称为泛型的类型参数（是一个形参）
    //T类型的真实类型会在创建对象时确定下来，隶属于对象的存在而存在
    //在静态方法中不可以使用泛型类中的泛型，因为静态方法隶属于类
    
    private String name;
    private T info;

    public person(String name, T info) {
        this.name = name;
        this.info = info;
    }

    public person() {
    }

    public String getName() {
        return name;
    }

    public T getInfo() {
        return info;
    }

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

    public void setInfo(T info) {
        this.info = info;
    }

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

public class GenericTest {

    @Test
    public void test(){
        //使用泛型后，类型就安全了
        person<Integer> p1 = new person<Integer>("张三", 20);
        //获取到的属性也清晰了
        Integer info1 = p1.getInfo();

        person<Boolean> p2 = new person<Boolean>("李四", true);
        Boolean info2 = p2.getInfo();

        person p3 = new person("王五", 5.36);
        Object info3 = p3.getInfo();
    }
}

3、泛型和继承的关系

class B1 extends A{}    //子类中没有处理父类的泛型，泛型类型就是Object，不推荐

class B2 extends A<Integer>{}   //子类在继承时，把父类的泛型确定下来了，使用起来最简单
class B3 extends A<person>{}    //在创建子类对象后，其泛型时固定的

class B4<T> extends A<T>{}      //子类在继承时仍然继续使用泛型，用起来最灵活

    @Test
    public void test1(){
        B1 b1 = new B1();
        Object t = b1.getT();

        B2 b2 = new B2();
        Integer t1 = b2.getT();

        B3 b3 = new B3();
        person t2 = b3.getT();

        B4 b4 = new B4();
        Object t3 = b4.getT();
        String t4 = new B4<String>().getT();
        Integer t5 = new B4<Integer>().getT();


    }

4、泛型方法

class GenericMethod<T>{
    public void test(T t){}

    public <E> E get(E e){     //E表示只可以在此方法中使用的某种类型，在返回值之前加<>
        return null;
    }
    //泛型方法中必须传入泛型类型的参数，如果不传泛型永远无法确定
    //泛型的类型由实参的类型来确定，所以它是和方法的某次调用相关
    public static <E> E get1(E e){ //静态方法也适用
        return null;
    }
}

    @Test
    public void test2(){
        String s = GenericMethod.get1("acf");     //泛型方法必须通过实参来告诉方法，泛型的具体类型是什么
        Boolean b = GenericMethod.get1(false);
        Object o = GenericMethod.get1(null);    //如果实参是null，将会导致泛型类型无法感知
        Integer i = GenericMethod.get1(200);

    }