Java 泛型示例 - 泛型方法，类，接口

Java Genrics 是 Java 5 中引入的最重要的功能之一。

如果您一直在使用Java Collections并使用版本 5 或更高版本，那么我确定您已经使用过它。

Java 中具有集合类的泛型非常容易，但是它提供了比仅创建集合类型更多的功能。

我们将在本文中尝试学习泛型的功能。如果我们使用专业术语，对泛型的理解有时会变得混乱，因此，我将尽量保持其简单易懂。

1. Java 中的泛型

Java 5 中添加了泛型，以提供编译时类型检查，并消除了ClassCastException使用集合类时常见的风险。整个收集框架都进行了重写，以使用泛型进行类型安全。让我们看看泛型如何帮助我们安全地使用集合类。

List list = new ArrayList();
list.add("abc");
list.add(new Integer(5)); 

for(Object obj : list){

    String str=(String) obj; 
}

上面的代码可以很好地编译，但是在运行时会引发ClassCastException，因为我们试图将列表中的对象强制转换为String，而其中一个元素是Integer类型。在Java 5之后，我们使用如下收集类。

List list1 = new ArrayList(); // java 7 ? List list1 = new ArrayList<>();
list1.add("abc");
//list1.add(new Integer(5)); //编译错误

for(String str : list1){
     //no type casting needed, avoids ClassCastException
}

请注意，在创建列表时，我们已指定列表中元素的类型为String。因此，如果我们尝试在列表中添加任何其他类型的对象，则该程序将引发编译时错误。还要注意，在循环中中，我们不需要列表中元素的类型转换，因此在运行时删除了ClassCastException。

2. Java通用类

我们可以使用泛型类型定义自己的类。泛型类型是通过类型进行参数化的类或接口。我们使用尖括号（<>）来指定类型参数。

为了了解其好处，我们假设有一个简单的类：

package com.journaldev.generics;
public class GenericsTypeOld {
    private Object t;
    public Object get() {
        return t;
    }
    public void set(Object t) {
        this.t = t;
    }
        public static void main(String args[]){
        GenericsTypeOld type = new GenericsTypeOld();
        type.set("Pankaj");
         String str = (String) type.get(); //type casting, error prone and can cause ClassCastException
    }
}

请注意，在使用此类时，我们必须使用类型转换，并且它可以在运行时产生ClassCastException。现在，我们将使用Java通用类替换如下所示的相同类。

package com.journaldev.generics;
public class GenericsType {
    private T t;
    public T get(){
        return this.t;
    }
    public void set(T t1){
        this.t=t1;
    }
    public static void main(String args[]){
        GenericsType type = new GenericsType<>();
        type.set("Pankaj"); //valid
        GenericsType type1 = new GenericsType(); //raw type
        type1.set("Pankaj"); //valid
        type1.set(10); //valid and autoboxing support
    }
}

注意main方法中GenericsType类的使用。我们不需要进行类型转换，并且可以在运行时删除ClassCastException。如果我们在创建时未提供类型，则编译器将发出警告，“ GenericsType是原始类型。

泛型类型GenericsType 的引用应参数化”。当我们不提供类型时，该类型就变成了类型Object，因此它允许String和Integer对象。但是，我们应始终尝试避免这种情况，因为在处理可能产生运行时错误的原始类型时，我们必须使用类型转换。

还要注意，它支持Java自动装箱。

3. Java通用接口

Comparable接口是接口中泛型的一个很好的例子，它写为：

package java.lang;
import java.util.*;

public interface Comparable {
    public int compareTo(T o);
}

以类似的方式，我们可以在Java中创建通用接口。我们也可以像Map界面具有多个类型参数。同样，我们也可以为参数化类型提供参数化值，例如new HashMap>();有效。

4. Java通用类型

Java通用类型命名约定可以帮助我们轻松理解代码，并且具有命名约定是Java编程语言的最佳实践之一。因此，泛型也带有自己的命名约定。通常，类型参数名称是单个大写字母，以可以实现与Java变量区分开。最常用的类型参数名称为：

• E –元素由Java Collections Framework广泛使用，例如ArrayList，Set等
• K –键（在Map中使用）
• N –数字
• T –类型
• V –值（在Map中使用）
• S，U，V等–第二，第三，第四类型

5. Java通用方法

有时我们不希望整个类都被参数化，在这种情况下，我们可以创建java泛型方法。由于构造函数是一种特殊的方法，因此我们也可以在构造函数中使用泛型类型。

这是一个显示Java泛型方法示例的类。

package com.journaldev.generics;
public class GenericsMethods {
    //Java Generic Method
    public static  boolean isEqual(GenericsType g1, GenericsType g2){
        return g1.get().equals(g2.get());
    }
    public static void main(String args[]){
        GenericsType g1 = newGenericsType<>();
        g1.set("Pankaj");
        GenericsType g2 = new GenericsType<>();
        g2.set("Pankaj");
        boolean isEqual = GenericsMethods.isEqual(g1, g2);
        //above statement can be written simply as
        isEqual = GenericsMethods.isEqual(g1, g2);
        //This feature, known as type inference, allows you to invoke a generic method as an ordinary method, without specifying a type between angle brackets.
        //Compiler will infer the type that is needed
    }
}

注意的isEqual方法签名显示了在方法中使用泛型类型的语法。另外，请注意如何在我们的Java的程序中使用这些方法。我们可以在调用这些方法时指定类型，也可以像普通方法一样调用它们。Java编译器足够聪明，可以确定要使用的变量的类型，这种功能称为类型变量。

6. Java泛型绑定类型参数

假设我们要限制可以在参数化类型中使用的对象的类型，例如在比较两个对象的方法中，并且我们要确保接受的对象是可比较的。要声明一个有界的类型参数，请列出类型参数的名称，然后列出扩展关键字，再加上其上限，以下下面的方法。

public static > int compare(T t1, T t2){
        return t1.compareTo(t2);
}

这些方法的调用与无界方法类似，不同之处在于，如果我们尝试使用任何非Comparable的类，则引发编译时错误。

绑定类型参数可以与方法以及类和接口一起使用。

Java泛型也支持多个范围，即。在这种情况下，A可以是接口或类。如果A是类，则B和C应该是接口。在多个范围内，我们不能有多个类。

7. Java泛型和继承

我们知道，如果A是B的子类，则Java继承允许我们将变量A分配给另一个变量B。因此，我们可能认为可以将A的任何泛型类型分配给B的泛型类型，但事实并非如此。让我们用一个简单的程序看看。

package com.journaldev.generics;
public class GenericsInheritance {
    public static void main(String[] args) {
        String str = "abc";
        Object obj = new Object();
        obj=str; // works because String is-a Object, inheritance in java
        MyClass myClass1 = new MyClass();
        MyClass