泛型的具体使用

泛型跟我们的成员属性一样,需要先声明才能使用.泛型的声明采用 <> 进行声明.
声明一般约定采用单个大写字母表示.常用的有 K E T V 等等字符
错误的案例:

正确案例

泛型类

泛型类一般指泛型的定义与类名一起.在创建实体对象时,指定泛型的类型

普通Person类:

public class Person {

    private String idCard;

    public Person(String idCard) {
        this.idCard = idCard;
    }
}

实例化过程

public static void main(String[] args) {
    Person p = new Person("431222xxxxxxxxxxxxxxxx");
}

        新加入需求，原本的身份证不仅只记录身份证，还需要记录地址 有效期 等等信息 这时我们需要创建一个实体IdentityCard进行信息的保存。此时需求改变带来的代码，发现我们的代码灵活度并不高.
我们可以使用泛型类进行解决

public class IdCard {

    private String name;

    private Integer age;

    private String address;

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

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

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }
}

public class PersonNew <T> {

    private T idCard;

    public PersonNew(T idCard) {
        this.idCard = idCard;
    }
}

实例化过程

public static void main(String[] args) {
    Person p = new Person("431222xxxxxxxxxxxxxxxx");

    PersonNew pn1 = new PersonNew("431222xxxxxx.....");
    IdCard idCard = new IdCard();
    idCard.setAddress("湖南");
    idCard.setAge(22);
    idCard.setName("李四");
    PersonNew pn2 = new PersonNew(idCard);
    PersonNew pn3 = new PersonNew(18);
}

通过泛型类,我们可以提升我们程序固定逻辑的灵活度

泛型方法

方法的泛型有两种:
实体方法
        实体方法可以使用在类中定义的泛型或者方法中定义的泛型.
静态方法
        不可以使用在类中定义的泛型,只能使用在静态方法上定义的泛型.

public class Demo07<T,K> {

    /**
     * 普通方法 使用类中定义的泛型
     * @param t
     * @param k
     * @return
     */
    public T method1(T t,K k){
        return (T)null;
    }

    /**
     * 普通方法使用 方法中定义的泛型
     * @param y
     * @param <S>
     * @param <Y>
     * @return
     */
    public <S,Y> K method2(Y y){
        return (K)null;
    }

    /**
     * 静态方法只能使用 方法中定义的泛型
     * @param j
     * @param <J>
     */
    public static <J> void method(J j){

    }
}

泛型接口

指在接口的定义时进行泛型的申明.
        接口是标准的指定者,指实现该接口的类必须实现其标准定义(即抽象方法).
        所以在接口上进行泛型的申明,或者说使用泛型接口,可以让我们的程序代码更加简洁,更加多变.
案例:
计算接口的定义

public interface Cal {

    int add(int a,int b);

    int sub(int a,int b);

    int mul(int a,int b);

    int div(int a,int b);
}

接口的实现

public class Calculator implements  Cal {
    @Override
    public int add(int a, int b) {
        return 0;
    }

    @Override
    public int sub(int a, int b) {
        return 0;
    }

    @Override
    public int mul(int a, int b) {
        return 0;
    }

    @Override
    public int div(int a, int b) {
        return 0;
    }
}

        大家会发现程序灵活度很差,当前结算接口的实现者,只能满足int类型数字计算,如果想满足其他数字类型的计算,需在接口中定义额外的方法.
此时,如果采用泛型接口即可完美解决问题.

计算泛型接口的定义:

public interface CalGeneric <T> {

    T add(T t1,T t2);
    T sub(T t1,T t2);
    T mul(T t1,T t2);
    T div(T t1,T t2);
}

计算泛型接口的实现者:

public class CalculatorDoubleGeneric implements CalGeneric<Double> {
    @Override
    public Double add(Double t1, Double t2) {
        return null;
    }

    @Override
    public Double sub(Double t1, Double t2) {
        return null;
    }

    @Override
    public Double mul(Double t1, Double t2) {
        return null;
    }

    @Override
    public Double div(Double t1, Double t2) {
        return null;
    }
}

如果我想实现float类型的计算需求. 我只需要实现CalGeneric< Float>即可。大大的提升代码的复用和改善程序的灵活度