Java基础-泛形

Java中的泛型

为什么需要泛型

• 通过以下两段代码就可知我们为什么需要泛型：

public int  add(int a, int b){
	return a+b;
}
public float  add(float a, float b){
	return a+b;
}

实际开发中，经常有数值类型求和的需求，例如实现int类型的加法, 有时候还需要实现long类型的求和, 如果还需要double类型的求和，需要重新在重载一个输入是double类型的add方法。

定义了一个List类型的集合，先向其中加入了两个字符串类型的值，随后加入一个Integer类型的值。这是完全允许的，因为此时list默认的类型为Object类型。在之后的循环中，由于忘记了之前在list中也加入了Integer类型的值或其他编码原因，很容易出现类似于//1中的错误。因为编译阶段正常，而运行时会出现“java.lang.ClassCastException”异常。因此，导致此类错误编码过程中不易发现

使用泛型的好处

• 适用于多种数据类型执行相同的代码
• 泛型中的类型在使用时指定，不需要强制类型转换

泛型类和泛型接口的定义

泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？

顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。

泛型的本质是为了参数化类型（在不创建新的类型的情况下，通过泛型指定的不同类型来控制形参具体限制的类型）。也就是说在泛型使用过程中，操作的数据类型被指定为一个参数，这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。

引入一个类型变量T（其他大写字母都可以，不过常用的就是T，E，K，V等等），并且用<>括起来，并放在类名的后面。泛型类是允许有多个类型变量的。

/*
* 泛型接口
**/
public interface Genertor<T> {
    public T next();
}
/*
* 类说明：泛型类
 */
public class NormalGeneric<K> {
    private K data;

    public NormalGeneric() {
    }

    public NormalGeneric(K data) {
        this.data = data;
    }

    public K getData() {
        return data;
    }

    public void setData(K data) {
        this.data = data;
    }

    public static void main(String[] args) {
        NormalGeneric<String> normalGeneric = new NormalGeneric<>();
        normalGeneric.setData("OK");
        //normalGeneric.setData(1);
        System.out.println(normalGeneric.getData());
        NormalGeneric normalGeneric1 = new NormalGeneric();
        normalGeneric1.setData(1);
        normalGeneric1.setData("dsf");
    }
}

/*
* 类说明：泛型类
 */
public class NormalGeneric2<T,K> {
    private T data;
    private K result;

    public NormalGeneric2() {
    }

    public NormalGeneric2(T data) {
        this();
        this.data = data;
    }

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }

    public NormalGeneric2(T data, K result) {
        this.data = data;
        this.result = result;
    }

    public K getResult() {
        return result;
    }

    public void setResult(K result) {
        this.result = result;
    }

    public static void main(String[] args) {
        NormalGeneric2<String,Integer> normalGeneric2 = new 				NormalGeneric2<>();
        normalGeneric2.setData("OK");
        System.out.println(normalGeneric2.getData());
        normalGeneric2.setResult(23);
        System.out.println(normalGeneric2.getResult());

    }
}

泛型方法的定义

泛型方法，是在调用方法的时候指明泛型的具体类型 ，泛型方法可以在任何地方和任何场景中使用，包括普通类和泛型类。注意泛型类中定义的普通方法和泛型方法的区别

public class GenericMethod {
	/*
	泛型方法
	*/
    public <T> T genericMethod(T...a){
        return a[a.length/2];
    }

    public void test(int x,int y){
        System.out.println(x+y);
    }

    public static void main(String[] args) {
        GenericMethod genericMethod = new GenericMethod();
        genericMethod.test(23,343);
        System.out.println(genericMethod.<String>genericMethod("mark","av","lance"));
        System.out.println(genericMethod.genericMethod(12,34));
    }
}

限定类型变量

有时候，我们需要对类型变量加以约束，比如计算两个变量的最小，最大值。

public static<T> T min(T a, T b){
	if (a.compareTo(b) > 0){
		return a;
	} else {
		return b;
	}
}

请问，如果确保传入的两个变量一定有compareTo方法？那么解决这个问题的方案就是将T限制为实现了接口Comparable的类

public static<T extends Comparable> T min(T a, T b){
	if (a.compareTo(b) > 0){
		return a;
	} else {
		return b;
	}
}

T extends Comparable中
T表示应该绑定类型的子类型，Comparable表示绑定类型，子类型和绑定类型可以是类也可以是接口。
如果这个时候，我们试图传入一个没有实现接口Comparable的类的实例，将会发生编译错误。

泛型中的约束和局限性

• 不能用基本类型实例化类型参数
• 运行时类型查询只适用于原始类型
• 泛型类的静态上下文类型变量失效
• 不能创建参数化类型的实例
• 不能捕获泛型类的实例

泛型类型的继承规则

现有一个类与其子类

public class Person {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String firstName) {
        this.name = name;
    }
}
public class Man extends Person {
}

有一个泛型类

public class H<T> {}

问：H<Person> 和 H<Man> 是继承关系吗？

答：他们之间没有任何关系

通配符类型

三种方式

• <?>被称作无限定的通配符
• <? extends X >表示类型的上界，类型参数是X的子类
• <？super X> 表示类型的下界，类型参数表示X的超类