复习使用~java泛型

java泛型

package com.example.generic;
import org.junit.jupiter.api.Test;
import java.util.ArrayList;
import java.util.List;
/**
 * @author lqh
 * @date 2020/6/9
 */
public class GenericMethodTest {
    @Test
    public void testGenericWildcard(){
        /**泛型的意义：把类型明确的工作推迟到创建对象或调用方法的时候
         * （只要编译时期没有警告，那么运行时期就不会出现ClassCastException异常）
         * 声明位置：类、方法、变量
         *
         * ?是所有泛型的父类
         * 前<>必须加泛型
         */

        //通配符的使用（设顶通配符的上限和下限）
        /**
         * 使用通配符<?>的集合只能添加null
         */
        List<?> list=new ArrayList<>();
       // list.add(5),编译出错
        list.add(null);
        /**
         *G<? extends Number>泛型的类型只能是Number和Number的子类
         */
        List<Integer> list1=new ArrayList<>();
        list1.add(127);
        getUpperNumber(list1);
        /**
         *G<? super Number>泛型的类型只能是Number和Number的父类
         */
        List<Number> list2=new ArrayList<>();
        list2.add(128);
        //getUpperNumber1(list1);编译不通过
        getUpperNumber1(list2);
        /**
         *G<? extends Comparable>只允许泛型为是实现Comparable接口的实现类的引用调用
         */
        List<String> list3=new ArrayList<>();
        list3.add(new String("abc"));
        //getUpperNumber1(list1);编译不通过
        getUpperNumber2(list3);


    }
    public void getUpperNumber(List <? extends Number> data){
        System.out.println(data.get(0));
    }
    public void getUpperNumber1(List <? super Number> data){
        System.out.println(data.get(0));
    }
    public void getUpperNumber2(List <? extends Comparable> data){
        System.out.println(data.get(0));
    }
    //使用通配符
    public static void test(List<?> list){
        //没有依赖关系，使用通配符，更灵活
    }
    //使用泛型方法
    public <T> void test2(List<T> list){
        //参数之间的类型有依赖关系，或者返回值与参数之间有依赖关系使用
    }

    @Test
    public void testGenericExtend(){
        /**
         * 类A是类B的父类，那么G<A>和G<B>没有子父类关系
         */
        ArrayList<Number> list= new ArrayList<>();
        ArrayList<Integer> list1= new ArrayList<>();
        //list=list1;编译出错

        /**
         * 类A是类B的父类，那么A<G>和B<G>存在子父类关系
         */
        List<Number> list3= new ArrayList<>();
        ArrayList<Number> list4= new ArrayList<>();
        list3=list4;

        /**
         * 如果原来存在子父类关系的两个类，一旦创建对象是加上的泛型类型不一样，那么这两个对象不存在字符类关系
         */
        List<Number> list5= new ArrayList<>();
        ArrayList<Integer> list6= new ArrayList<>();
        //list5=list6；编译出错

        /**
         * 那么G<A>和G<?>没有子父类关系存在子父类关系
         */
        ArrayList<?> list7= new ArrayList<>();
        ArrayList<Number> list8= new ArrayList<>();
        list7=list8;

        /**
         * G<?>是G<String>、G<Integer>、G<Object>等各种泛型G的父类
         */
        ArrayList<?> list9= new ArrayList<>();
        ArrayList<Number> list10= new ArrayList<>();
        ArrayList<Integer> list11= new ArrayList<>();
        ArrayList<String> list12= new ArrayList<>();
        list9=list10;
        list9=list11;
        list9=list12;
    }
    public static <E> void printArray(E[] inputArray){
        for (E element:inputArray){
            System.out.printf("%s ",element);
        }
    }
    @Test
    public void testGeneric(){
        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("整形数组的元素：");
        printArray(intArray);
        System.out.println("双精度数组的元素：");
        printArray(doubleArray);
        System.out.println("字符型数组的元素：");
        printArray(charArray);
    }
    /**
     *比较三个值并返回最大值
     */
    public static <T extends Comparable<T>> T maximum(T x, T y, T z)
    {
        T max = x; // 假设x是初始最大值
        if ( y.compareTo( max ) > 0 ){
            max = y; //y 更大
        }
        if ( z.compareTo( max ) > 0 ){
            max = z; // 现在 z 更大
        }
        return max; // 返回最大对象
    }
    @Test
    public void testMximum(){
        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","pear",
                "apple", "orange", maximum( "pear", "apple", "orange" ) );
    }

    /**
     * 静态方法中不能使用类的泛型
     * 不能再try-catch中使用泛型定义，异常类不能是泛型
     * 泛型中指定的不能是基本数据类型，可以使用包装类替代
     * 编译是ArrayList<String>和ArrayList<Integer>是两种类型，但是，在运行时只有一个ArrayList被加载到JVM中
     */

}