带你捋清泛型知识点

太过爱你忘了你带给我的痛 2024-03-16 22:44 63阅读 0赞

#### 泛型 ####

*  泛型的定义
 *   *  定义
     *  例子：
 *  泛型的使用
 *   *  泛型类
     *  泛型方法
     *  泛型接口
     *  泛型方法
     *  泛型方法基本用法
     *   *  类中的泛型方法
         *  泛型方法与可变参数
         *  
     *  泛型上下边界

## 泛型的定义 ##

### 定义 ###

泛型在java中有很重要的地位，在面向对象编程及各种设计模式中有非常广泛的应用。

Java 泛型（generics）是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型。
    泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。

`问题` ：

假定我们有这样一个需求：写一个排序方法，能够对整型数组、字符串	数组甚至其他任何类型的数组进行排序，该如何实现？
    答案是可以使用 Java 泛型。
    使用 Java 泛型的概念，我们可以写一个泛型方法来对一个对象数组排序。然后，调用该泛型方法来对整型数组、浮点数数组、字符串数组等进行排序。

### 例子： ###

List arrayList = new ArrayList();
    arrayList.add("aaaa");
    arrayList.add(100);
    
    for(int i = 0; i< arrayList.size();i++){
        
        String item = (String)arrayList.get(i);
        Log.d("泛型测试","item = " + item);
    }

结果：

java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String

例子中添加了一个String类型，添加了一个Integer类型，再使用时都以String的方式使用，因此程序崩溃了。为了解决类似这样的问题（在编译阶段就可以解决），泛型应运而生。

我们将第一行声明初始化list的代码更改一下，编译器会在编译阶段就能够帮我们发现类似这样的问题。

List<String> arrayList = new ArrayList<String>();
    ...
    //arrayList.add(100); 在编译阶段，编译器就会报错

## 泛型的使用 ##

泛型有三种使用方式，分别为：泛型类、泛型接口、泛型方法  
`java 中泛型标记符`：

E - Element (在集合中使用，因为集合中存放的是元素)
     T - Type（Java 类）
     K - Key（键）
     V - Value（值）
     N - Number（数值类型）
     ？ - 表示不确定的 java 类型

### 泛型类 ###

泛型类的声明和非泛型类的声明类似，除了在类名后面添加了类型参数声明部分。
    和泛型方法一样，泛型类的类型参数声明部分也包含一个或多个类型参数，参数间用逗号隔开。一个泛型参数，也被称为一个类型变量，是用于指定一个泛型类型名称的标识符。因为他们接受一个或多个参数，这些类被称为参数化的类或参数化的类型。

`语法`：

class 类名称 <泛型标识：可以随便写任意标识号，标识指定的泛型的类型>{
      private 泛型标识 /*（成员变量类型）*/ var; 
      .....
    
      }
    }

例子：

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("整型值为 :", integerBox.get());
        System.out.printf("字符串为 :", stringBox.get());
      }
    }

编译以上代码，运行结果如下所示：

整型值为 :10
    
    字符串为 :菜鸟教程

### 泛型方法 ###

### 泛型接口 ###

泛型接口与泛型类的定义及使用基本相同。泛型接口常被用在各种类的生产器中

//定义一个泛型接口
    public interface Example<T> {
        
        public T text();
    }

当实现泛型接口的类，未传入泛型实参时：

/**
     * 未传入泛型实参时，与泛型类的定义相同，在声明类的时候，需将泛型的声明也一起加到类中
     * 即：class ExampleImpl<T> implements Example<T>{
     * 如果不声明泛型，如：class ExampleImplimplements Example<T>，编译器会报错："Unknown class"
     */
    class ExampleImpl<T> implements Example<T>{
        
        @Override
        public T text() {
        
            return null;
        }
    }

当实现泛型接口的类，传入泛型实参时：

/**
     * 传入泛型实参时：
     * 定义一个生产器实现这个接口,虽然我们只创建了一个泛型接口Example<T>
     * 但是我们可以为T传入无数个实参，形成无数种类型的Example接口。
     * 在实现类实现泛型接口时，如已将泛型类型传入实参类型，则所有使用泛型的地方都要替换成传入的实参类型
     * 即：如传入String类型。Example<T>，public T text();中的的T都要替换成传入的String类型。
     */
    public class ExampleImpl implements Example<String> {
        
    
        private String[] e= new String[]{
        "Apple", "Banana", "Pear"};
    
        @Override
        public String text() {
        
            Random rand = new Random();
            return e[rand.nextInt(3)];
        }
    }

### 泛型方法 ###

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

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

`语法`：

public class 类名{
    
    	修饰符 <泛型类型> 返回值类型 方法名(泛型类型){
    		
    	}
    }

### 泛型方法基本用法 ###

例子：

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 ); // 传递一个字符型数组
        } 
    }

编译以上代码，运行结果如下所示：

整型数组元素为:
    1 2 3 4 5 
    
    双精度型数组元素为:
    1.1 2.2 3.3 4.4 
    
    字符型数组元素为:
    H E L L O

区别：  
`泛型类，是在实例化类的时候指明泛型的具体类型；泛型方法，是在调用方法的时候指明泛型的具体类型 。`

#### 类中的泛型方法 ####

泛型方法可以出现杂任何地方和任何场景中使用。但是有一种情况是非常特殊的，当泛型方法出现在泛型类中时

public class GenericFruit {
        
    
        //水果类
        class Fruit{
        
            @Override
            public String toString() {
        
                return "fruit";
            }
        }
    
        class Apple extends Fruit{
        
            @Override
            public String toString() {
        
                return "apple";
            }
        }
        
    	//人类
        class Person{
        
            @Override
            public String toString() {
        
                return "Person";
            }
        }
    
    	//泛型类
        class GenerateTest<T>{
        
        	
            public void show_1(T t){
        
                System.out.println(t.toString());
            }
    
            //在泛型类中声明了一个泛型方法，使用泛型E，这种泛型E可以为任意类型。可以类型与T相同，也可以不同。
            //由于泛型方法在声明的时候会声明泛型<E>，因此即使在泛型类中并未声明泛型，编译器也能够正确识别泛型方法中识别的泛型。
            public <E> void show_3(E t){
        
                System.out.println(t.toString());
            }
    
            //在泛型类中声明了一个泛型方法，使用泛型T，注意这个T是一种全新的类型，可以与泛型类中声明的T不是同一种类型。
            public <T> void show_2(T t){
        
                System.out.println(t.toString());
            }
        }
    
        public static void main(String[] args) {
        
            Apple apple = new Apple();
            Person person = new Person();
    
            GenerateTest<Fruit> generateTest = new GenerateTest<Fruit>();
            //apple是Fruit的子类，所以这里可以
            generateTest.show_1(apple);
            //编译器会报错，因为泛型类型实参指定的是Fruit，而传入的实参类是Person
            //generateTest.show_1(person);
    
            //使用这两个方法都可以成功
            generateTest.show_2(apple);
            generateTest.show_2(person);
    
            //使用这两个方法也都可以成功
            generateTest.show_3(apple);
            generateTest.show_3(person);
        }
    }

#### 泛型方法与可变参数 ####

public <T> void printMsg( T... args){
        
        for(T t : args){
        
            Log.d("泛型测试","t is " + t);
        }
    }

结果：

printMsg("111",222,"aaaa","2323.4",55.55);

####  ####

静态方法有一种情况需要注意一下，那就是在类中的静态方法使用泛型：**静态方法无法访问类上定义的泛型；如果静态方法操作的引用数据类型不确定的时候，必须要将泛型定义在方法上。**

即：**如果静态方法要使用泛型的话，必须将静态方法也定义成泛型方法 。**

public class StaticGenerator<T> {
        
        ....
        ....
        /**
         * 如果在类中定义使用泛型的静态方法，需要添加额外的泛型声明（将这个方法定义成泛型方法）
         * 即使静态方法要使用泛型类中已经声明过的泛型也不可以。
         * 如：public static void show(T t){..},此时编译器会提示错误信息：
              "StaticGenerator cannot be refrenced from static context"
         */
        public static <T> void show(T t){
        
    
        }
    }

### 泛型上下边界 ###

在使用泛型的时候，我们还可以为传入的泛型类型实参进行上下边界的限制，如：类型实参只准传入某种类型的父类或某种类型的子类。

*  为泛型添加上边界，即传入的类型实参必须是指定类型的子类型

public void showKeyValue1(Generic<? extends Number> obj){
        
       Log.d("泛型测试","key value is " + obj.getKey());
    }

Generic<String> generic1 = new Generic<String>("11111");
    Generic<Integer> generic2 = new Generic<Integer>(2222);
    Generic<Float> generic3 = new Generic<Float>(2.4f);
    Generic<Double> generic4 = new Generic<Double>(2.56);
    
    //这一行代码编译器会提示错误，因为String类型并不是Number类型的子类
    //showKeyValue1(generic1);
    
    showKeyValue1(generic2);
    showKeyValue1(generic3);
    showKeyValue1(generic4);