泛型

泛型

一、简介

Java泛型是JDK5中引入的一个新特性，泛型提供了编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型

泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。

二、泛型方法

package com.jp.javaSE.泛型.泛型方法;

import com.sun.org.apache.xml.internal.security.Init;

/**
 * @program: mianjing
 * @description:
 * @author:
 * @create: 2020-10-29 20:30
 **/
public class GenericMethodTest {
    public static void main(String[] args) {
        Integer[] intArray={1,2,3,4,5};
        Double[] doubleArray={1.1,2.2,3.3,4.4};
        Character[] charArray={'H','E','L','L','O'};

        System.out.println("\n整型数组元素为：");
        printArray(intArray);

        System.out.println("\n双精度型数组元素为：");
        printArray(doubleArray);

        System.out.println("\n字符型数组元素为：");
        printArray(charArray);
    }

    //泛型方法 printArray
    public static <E> void printArray(E[] inputArray){
        for(E element : inputArray){
            System.out.printf("%s ", element);
        }
        System.out.println();
    }
}

如果要声明一个有界的类型参数，首先列出类型参数的名称，后跟extends关键字，最后紧跟它的上界。

package com.jp.javaSE.泛型.泛型方法;

/**
 * @program: mianjing
 * @description:
 * @author:
 * @create: 2020-10-29 20:55
 **/
public class MaximumTest {
    public static void main(String[] args) {
        System.out.printf("%d,%d和%d中最大的数为%d\n\n",
                3,4,5,maximum(3,4,5));

        System.out.printf("%.1f,%.1f和%.1f中最大的数为%.1f\n\n",
                6.6,8.8,7.7,maximum(6.6,8.8,7.7));

        System.out.printf("%s,%s和%s中最大的数为%s\n",
                "apple","orange","pear",maximum("apple","orange","pear"));
    }

    public static <T extends Comparable<T>> T maximum(T x,T y,T z){
        T max=x;
        if (y.compareTo(max)>0){
            max=y;
        }
        if (z.compareTo(max)>0){
            max=z;
        }
        return max;
    }
}

三、泛型类

和泛型方法一样，泛型类的类型参数声明部分也包含一个或者多个类型参数，参数间用逗号隔开。

package com.jp.javaSE.泛型.泛型类;

/**
 * @program: mianjing
 * @description:
 * @author: 
 * @create: 2020-10-29 21:07
 **/
public class Box<T> {
    private T t;

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

    public T get() {
        return t;
    }

    public static void main(String[] args) {
        Box<Integer> integerBox=new Box<Integer> ();
        Box<String> stringBox=new Box<String> ();

        integerBox.add(new Integer(10));
        stringBox.add(new String("菜鸟教程"));

        System.out.printf("整数值为：%d\n\n",integerBox.get());
        System.out.printf("字符串为：%s\n",stringBox.get());

    }
}

类型通配符一般是使用？代替具体的参数。例如List<?>在逻辑上是List,List等所有List<具体类型实参>的父类

package com.jp.javaSE.泛型.类型通配符;
import	java.util.ArrayList;
import	java.util.List;

/**
 * @program: mianjing
 * @description:
 * @author: 
 * @create: 2020-10-29 21:20
 **/
public class GenericTest {
    public static void main(String[] args) {
        List<String> name = new ArrayList<String> ();
        List<Integer> age = new ArrayList<Integer> ();
        List<Number> number = new ArrayList<Number> ();

        name.add("icon");
        age.add(18);
        number.add(314);

        getData(name);
        getData(age);
        getData(number);

        //getUperNumber(name);此处行不通，因为已经限制了参数的类型必须为Number
        getUperNumber(age);
        getUperNumber(number);

    }

    public static void getData(List<?> date){
        System.out.println("date:"+date.get(0));
    }

    //限定通配符的上限
    //要声明一个有界的类型参数，首先列出类型参数的名称，后跟extends关键字，最后紧跟它的上界
    public static void getUperNumber(List<? extends Number> data){
        System.out.println("data:"+data.get(0));
    }
}