Java 泛型学习复习总结（二）-2021-05-21

集合类声明容器的元素

可以使用K 和V 两个字符代表容器中的键值与键值相对应的具体值。
在项目中创建MutiOverClass类，在该类中使用集合类声明容器的元素。

package com.Generic;

import java.util.HashMap;
import java.util.Map;

public class MutiOverClass<K,V> {
    public Map<K,V> M = new HashMap<K,V>();//定义一个集合HashMap实例
    public void put(K k,V v){ //设置put（）方法，将对应的键值与键名存入集合对象中
        M.put(k,v);
    }
    public V get(K k){
        return M.get(k);       //根据键值名获取键值
    }

    public static void main(String[] args) {
        //实例化泛型类对象
        MutiOverClass<Integer,String> mu = new MutiOverClass<Integer,String>();
        //根据集合的长度循环将键名与具体的值放入集合中
        for(int i = 0;i<=50 ;i++){
            mu.put(i,"我是集合类成员"+ i);
        }

        //使用get（）方法获取集合中的值
        for(int i = 0; i< mu.M.size();i++){
            System.out.println(mu.get(i));
        }
    }
}

下面的代码演示ArrayList,HaspMap<K,V> ,HashSet, Vector泛型定义的使用方法.

package com.Generic;

import java.util.*;

public class AnyClass {
    public static void main(String[] args) {
        // 定义ArrayList容器，设置容器内的值类型为Integer
        ArrayList<Integer> a = new ArrayList<Integer>();
        a.add(1); // 为容器添加新值
        for (int i = 0; i < a.size(); i++) {
            // 根据容器的长度循环显示容器内的值
            System.out.println("获取ArrayList容器的值：" + a.get(i));
        }
        // 定义HashMap容器，设置容器的键名与键值类型分别为Integer与String型
        Map<Integer, String> m = new HashMap<Integer, String>();
        for (int i = 0; i < 5; i++) {
            m.put(i, "成员" + i); // 为容器填充键名与键值
        }
        for (int i = 0; i < m.size(); i++) {
            // 根据键名获取键值
            System.out.println("获取Map容器的值" + m.get(i));
        }
        // 定义Vector容器，使容器中的内容为String型
        Vector<String> v = new Vector<String>();
        for (int i = 0; i < 5; i++) {
            v.addElement("成员" + i); // 为Vector容器添加内容
        }
        for (int i = 0; i < v.size(); i++) {
            // 显示容器中的内容
            System.out.println("获取Vector容器的值" + v.get(i));
        }
    }
}

限制泛型可用类型

默认可以使用任何类型来实例化一个泛型类对象，但Java中也对泛型类实例的类型作了限制，语法如下：
class 类名称
其中，anyClass指某个接口或类。
使用泛型限制后，泛型类的类型必须实现或继承了anyClass这个接口或类，无论anyClass是接口还是类，在进行泛型限制时都必须使用关键字extends。查看下面的代码：

package com.Generic;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;

public class LimitClass<T extends List> { //限制泛型的类型
    public static void main(String[] args) {
        //可以实例化已经实现List接口的类
        LimitClass<ArrayList> i1 = new LimitClass<ArrayList>();
        LimitClass<LinkedList> i2 = new LimitClass<LinkedList>();
        //下面的语句是错误的，因为HashMap没有实现List（）接口
        //LimitClass<HashMap> i3 = new LimitClass<HashMap>();
    }
}

使用类型通配符

泛型方法

你可以写一个泛型方法，该方法在调用时可以接收不同类型的参数。根据传递给泛型方法的参数类型，编译器适当地处理每一个方法调用。

下面是定义泛型方法的规则：

1. 所有泛型方法声明都有一个类型参数声明部分（由尖括号分隔），该类型参数声明部分在方法返回类型之前（在下面例 子中的）。
2. 每一个类型参数声明部分包含一个或多个类型参数，参数间用逗号隔开。一个泛型参数，也被称为一个类型变量，是用于指定一个泛型类型名称的标识符。
3. 类型参数能被用来声明返回值类型，并且能作为泛型方法得到的实际参数类型的占位符。
4. 泛型方法体的声明和其他方法一样。注意类型参数只能代表引用型类型，不能是原始类型（像int,double,char的等）。

查看下面的代码，演示如何使用泛型方法打印不同类型的数组元素：

public class GenericMethodTest
{
   // 泛型方法 printArray                         
   public static < E > void printArray( E[] inputArray )
   {
      // 输出数组元素            
         for ( E element : inputArray ){        
            System.out.printf( "%s ", element );
         }
         System.out.println();
    }
 
    public static void main( String args[] )
    {
        // 创建不同类型数组： Integer, Double 和 Character
        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( "\n双精度型数组元素为:" );
        printArray( doubleArray ); // 传递一个双精度型数组
 
        System.out.println( "\n字符型数组元素为:" );
        printArray( charArray ); // 传递一个字符型数组
    } 
}

有界的类型参数:
可能有时候，你会想限制那些被允许传递到一个类型参数的类型种类范围。例如，一个操作数字的方法可能只希望接受Number或者Number子类的实例。这就是有界类型参数的目的。
要声明一个有界的类型参数，首先列出类型参数的名称，后跟extends关键字，最后紧跟它的上界。

查看下面代码：
下面的例子演示了"extends"如何使用在一般意义上的意思"extends"（类）或者"implements"（接口）。该例子中的泛型方法返回三个可比较对象的最大值。

public class MaximumTest
{
   // 比较三个值并返回最大值
   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; // 返回最大对象
   }
   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","pear",
         "apple", "orange", maximum( "pear", "apple", "orange" ) );
   }
}