java泛型

百度百科：

Java泛型是J2 SE1.5中引入的一个新特性，其本质是参数化类型，也就是说所操作的数据类型被指定为一个参数（type parameter）这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。

百度百科：

java集合（Collection）中元素的类型是多种多样的。例如，有些集合中的元素是Byte类型的，而有些则可能是String类型的，等等。Java允许程序员构建一个元素类型为Object的Collection，其中的元素可以是任何类型在Java SE 1.5之前，没有泛型（Generics）的情况下，通过对类型Object的引用来实现参数的“任意化”，“任意化”带来的缺点是要作显式的强制类型转换，而这种转换是要求开发者对实际参数类型可以在预知的情况下进行的。对于强制类型转换错误的情况，编译器可能不提示错误，在运行的时候才出现异常，这是一个安全隐患。因此，为了解决这一问题，J2SE 1.5引入泛型也是自然而然的了 

第一是泛化。可以用T代表任意类型Java语言中引入泛型是一个较大的功能增强不仅语言、类型系统和编译器有了较大的变化，以支持泛型，而且类库也进行了大翻修，所以许多重要的类，比如集合框架，都已经成为泛型化的了，这带来了很多好处。

第二是类型安全。泛型的一个主要目标就是提高Java程序的类型安全，使用泛型可以使编译器知道变量的类型限制，进而可以在更高程度上验证类型假设。如果不用泛型，则必须使用强制类型转换，而强制类型转换不安全，在运行期可能发生ClassCast Exception异常，如果使用泛型，则会在编译期就能发现该错误。

第三是消除强制类型转换。泛型可以消除源代码中的许多强制类型转换，这样可以使代码更加可读，并减少出错的机会。

第四是向后兼容。支持泛型的Java编译器（例如JDK1.5中的Javac）可以用来编译经过泛型扩充的Java程序（Generics Java程序），但是现有的没有使用泛型扩充的Java程序仍然可以用这些编译器来编译。 

泛型有三种使用方式，分别为：泛型类、泛型接口、泛型方法

重载方法代码：

package com.company.test.genericity;

import java.math.BigDecimal;


public class TestUtile {


    public static int multiply(int a, int b) {
        System.out.println(a + "*" + b + "=" + (a * b));
        return a * b;
    }

    public static float multiply(float a, float b) {
        System.out.println(a + "*" + b + "=" + (a * b));
        return a * b;
    }

    public static double multiply(double a, double b) {
        BigDecimal a1 = new BigDecimal(Double.toString(a));

        BigDecimal b1 = new BigDecimal(Double.toString(b));
        System.out.println(a + "*" + b + "=" + (a1.multiply(b1).doubleValue()));
        return a1.multiply(b1).doubleValue();
    }

}

public class Test {

    public static void main(String[] args) {
        TestUtile.multiply(2, 3);

        TestUtile.multiply(2.3f, 2.5f);

        TestUtile.multiply(2.66, 2.77);

    }
}

输出结果：

改为泛型方法： 

package com.company.test.genericity;

import java.math.BigDecimal;


public class TestUtile {

    
    public static  BigDecimal multiply(T a, T b) {
        BigDecimal a1 = new BigDecimal(String.valueOf(a));

        BigDecimal b1 = new BigDecimal(String.valueOf(b));
        System.out.println(a + "*" + b + "=" + (a1.multiply(b1).doubleValue()));
        return a1.multiply(b1);
    }
}

public class Test {

    public static void main(String[] args) {
        TestUtile.multiply(2, 3);

        TestUtile.multiply(2.3f, 2.5f);

        TestUtile.multiply(2.66, 2.77);

    }
}

 输出结果：

(1)简单泛型

public class Demo1 {
    private T t ;

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }

}

public class Test {

    public static void main(String[] args) {

        Demo1 demo1 = new Demo1<>();
        demo1.setT("泛型测试");
        System.out.println("输出结果："+demo1.getT());
    }
}

输出结果：

(2)多元泛型

package com.company.test.genericity;



public class Demo2 {
    private K key ;

    private V value;

    public K getKey() {
        return key;
    }

    public void setKey(K key) {
        this.key = key;
    }

    public V getValue() {
        return value;
    }

    public void setValue(V value) {
        this.value = value;
    }

    @Override
    public String toString() {
        return "Demo2{" +
                "key=" + key +
                ", value=" + value +
                '}';
    }
}

public class Test {

    public static void main(String[] args) {

        Demo2 demo2 = new Demo2<>();
        demo2.setKey("百度");
        demo2.setValue("www.baidu.com");
        System.out.println("输出结果："+demo2.toString());
    }
}

输出结果：

package com.company.test.genericity;

import java.lang.reflect.InvocationTargetException;


public class ObjectFactory {

    
    public T getObject(Class c) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        //c.newInstance(); jdk9以上这个方法过时了 不过依然可以用
        //创建对象
        T t = c.getDeclaredConstructor().newInstance();
        return t;
    }
}

public class Test {

    public static void main(String[] args) throws ClassNotFoundException, InvocationTargetException, NoSuchMethodException, InstantiationException, IllegalAccessException {

        ObjectFactory objectFactory = new ObjectFactory();
        Object object = objectFactory.getObject(Class.forName("com.company.test.genericity.Person"));
        Person person = (Person)object;
        person.setAge(12);
        person.setName("张三");
        person.setSex("男");
        person.setPhoneNumber("12345678945");
        System.out.println("输出结果"+person);
    }
}

说明：

1.定义泛型方法时，必须在返回值前边加一个，来声明这是一个泛型方法，持有一个泛型T，才可以返回泛型T

2.Class类型的变量c，可以用来创建泛型类的对象，因为不知道具体的T的类型，所以不能直接new一个对象需要使用全限定名来指定具体的参数类型，比如传入的全限定名"com.company.test.genericity.Person"则Class中的T就是Person，那么返回的Object也就是Person

public interface DemoService {

    T sayHello(T t);
}


public class DemoServiceImpl implements DemoService{
    @Override
    public T sayHello(T t) {
        return t;
    }
}


public class Test {

    public static void main(String[] args) {

      DemoService  demoService =  new DemoServiceImpl<>();
        String hello = demoService.sayHello("hello");
        System.out.println("输出结果："+hello);
    }
}

输出结果：

无限制通配符
extends 关键字声明了类型的上界，表示参数化的类型可能是所指定的类型，或者是此类型的子类
super 关键字声明了类型的下界，表示参数化的类型可能是指定的类型，或者是此类型的父类

使用的规则就是：生产者有上限、消费者有下限
1. 如果参数化类型表示一个 T 的生产者，使用 < ? extends T>;
2. 如果它表示一个 T 的消费者，就使用 < ? super T>；
3. 如果既是生产又是消费，那使用通配符就没什么意义了，因为你需要的是精确的参数类型。

1.泛型上限 

public class Demo3 {
    private T t ;        // 定义泛型变量

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }

    @Override
    public String toString() {
        return "Demo3{" +
                "t=" + t +
                '}';
    }
}


public class Test {

    public static void main(String[] args) {

        Demo3 demo3 = new Demo3<>();
        demo3.setT(1245);
        System.out.println("输出结果："+demo3);
    }
}

输出结果：

2.泛型下限 

package com.company.test.genericity;


public class Demo4 {

    private T t;

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }

    @Override
    public String toString() {
        return "Demo4{" +
                "t=" + t +
                '}';
    }
    public static void test(Demo4 param){
        System.out.println("参数结果："+param);
    }
    public static void main(String[] args) {
        Demo4 stringDemo4 = new Demo4<>();
        stringDemo4.setT("参数下限");
        test(stringDemo4);
        Demo4