Java 泛型方法，通配符使用，有界类型参数

泛型方法，通配符使用，有界类型参数

• 泛型方法：带类型参数的方法，可以为静态和非静态
• 类的成员方法和构造方法都可以定义为泛型方法
• 类型参数的作用域仅限于声明的方法和构造方法
• 泛型方法必须在方法返回值前指定泛型

/**
 * 泛型方法：带类型参数的方法，可以为静态和非静态
 * 类的成员方法和构造方法都可以定义为泛型方法
 * 类型参数的作用域仅限于声明的方法和构造方法
 * 泛型方法必须在方法返回值前指定泛型
 */
interface Entry<K,V>{ //泛型接口
    public K getKey() ;
    public V getValue();
}
class Pair <K,V> implements Entry<K,V>{ //泛型类实现泛型接口
    private K key ; //成员变量
    private V value ;
    public Pair(){} //不带参数的构造方法
    public Pair(K key, V value){ //带两个参数的构造方法
        this.key = key ;
        this.value = value ;
    }
    public void setKey(K key){ //修改键的方法
        this.key = key ;
    }
    public void setValue(V value){ //修改值的方法
        this.value = value ;
    }
    @Override
    public K getKey() { //重写访问键的方法
        return key;
    }
    @Override
    public V getValue() {//重写访问值的方法
        return value;
    }
}

public class Util {
    //交换数组元素的泛型方法
    public static <T> void swap(T [] array, int i, int j){ //需要在方法返回值前指定泛型
        T temp = array[i] ;
        array[i] =  array[j] ;
        array[j] = temp ;
    }
    //比较泛型对象的方法
    public static <K,V> boolean compareTo(Pair<K,V> p1 , Pair<K,V> p2){
        return p1.getKey().equals(p2.getKey()) && p1.getValue().equals(p2.getValue()) ;
    }
    public static void main(String[] args){
        Integer [] array = new Integer[]{1,2,3,4} ;
        swap(array,0,3); //交换数组元素
        for(Integer m : array){ //增强for循环输出元素
            System.out.print(m + " ") ;
        }
        Pair <Integer, String> p1 = new Pair<>(1,"one") ; //泛型类型实例化
        Pair <Integer, String> p2 = new Pair<>(2,"two") ;
        System.out.println(compareTo(p1,p2)) ;//调用方法比较p1与p2对象

    }
}

• 通配符的使用，问号？就是通配符，表示方法可接受元素是任何类型的对象
• 当需要传递的对象类型不确定时，可以使用通配符

import java.util.ArrayList;
import java.util.List;

/**
 * 通配符的使用，问号？就是通配符，表示方法可接受元素是任何类型的对象
 * 当需要传递的对象类型不确定时，可以使用通配符
 */
public class WildCardDemo {
    public static void printList(List<?> list){ //静态的打印列表的方法,List对象的类型不确定
        for(Object m : list){ //增强for循环打印列表数据
            System.out.print(m + " ") ;
        }
    }
    public static void main(String[] args){
        List <Integer> list = new ArrayList<>() ; //整数泛型集合实例化
        list.add(new Integer(1)) ;
        list.add(new Integer(2)) ;
        list.add(new Integer(3)) ;
        printList(list); //传递List对象的类型为整数
        List <String> myList = new ArrayList<>();//字符串泛型集合实例化
        myList.add("dog") ;
        myList.add("cat") ;
        myList.add("rabbit") ;
        printList(myList) ;//传递List对象的类型为字符串
    }
}

• 有界类型参数
• 限制传递类型参数的类型种类
• 有界类型分为有上界和有下界：
• 上界：？ extends 上界类型
• 下界：？ super 下届类型

import java.util.ArrayList;
import java.util.List;
/**
 * 有界类型参数
 * 限制传递类型参数的类型种类
 * 有界类型分为有上界和有下界：
 * 上界：？ extends 上界类型
 * 下界：？ super 下届类型
 */
public class BoundedTypeDemo {
    //限定传递给改方法的事Number类机器子类的列表，Number类事列表中元素的上界
    public static double getAverage(List<? extends Number> numberList){
        double total = 0.0 ;
        for(Number number : numberList){ //增强for循环求和
            total += number.doubleValue() ;
        }
        return total / numberList.size() ;
    }
    public static void main(String[] args){
        List <Integer> integerList = new ArrayList<>() ;//整型的泛型集合实例化
        integerList.add(3) ;
        integerList.add(30) ;
        integerList.add(300) ;
        System.out.println(getAverage(integerList)) ; //调用方法打印平均值
        List <Double> doubleList = new ArrayList<>() ; //浮点型泛型集合实例化
        doubleList.add(5.5) ;
        doubleList.add(55.5) ;
        System.out.println(getAverage(doubleList)) ;
    }
}