Java函数中常用的接口与泛型的使用方法

Java中函数的接口和泛型是很常用的特性，它们能够让代码更加灵活、可扩展和可重用。下面我们将分别介绍它们的使用方法。

一、接口

Java中，接口是抽象类的高级形式，它只定义方法的声明而不提供实现。接口可以看做是一种协议，规定了哪些方法必须被实现，但是没有具体实现。接口可以被多个不同的实现类实现，这个特性也是Java中“多态”的重要体现之一。

以下是一个简单的接口定义：

public interface MyInterface {
    public void doSomething();
    public int getNumber(int n);
}

这个接口定义了两个方法，doSomething和getNumber，并且这两个方法都没有具体的实现。接口的使用方法如下：

1. 实现接口

实现接口是指在类中实现接口内部声明的所有方法。一个类可以实现多个接口，用逗号分隔。例如，以下是一个实现MyInterface接口的示例：

public class MyClass implements MyInterface {
    public void doSomething() {
        System.out.println("doSomething");
    }

    public int getNumber(int n) {
        return n * 2;
    }
}

注意，在接口中定义的方法都必须被实现，否则会编译出错。

2. 接口的继承

接口可以像类一样进行继承，使用关键字extends。例如，以下是一个继承MyInterface接口的示例：

public interface MySubInterface extends MyInterface {
    public boolean isTrue();
}

这个接口继承了MyInterface，并且添加了一个新的方法isTrue()。

3. 接口的应用

接口的一个常见应用是定义回调函数。例如：

public interface OnDownloadCompleteListener {
    public void onDownloadComplete();
}

这个接口定义了一个回调函数，当下载完成时调用onDownloadComplete()方法。在使用时，程序需要传入一个具体的OnDownloadCompleteListener实例，并在下载完成时调用该实例的onDownloadComplete()方法。

二、泛型

Java泛型在Java 5.0中被引入，它可以让程序员在编码阶段确定数据类型，在程序运行的过程中避免类型转换异常。泛型类型可以是类、接口或方法。

以下是一个简单的泛型类定义：

public class GenericClass<T> {
    private T value;

    public GenericClass(T value) {
        this.value = value;
    }

    public T getValue() {
        return value;
    }
}

这个泛型类的类型为T，在实例化时需要传入一个具体的类型。例如：

GenericClass<Integer> intObj = new GenericClass<Integer>(10);
System.out.println(intObj.getValue());  // 10
GenericClass<String> strObj = new GenericClass<String>("hello");
System.out.println(strObj.getValue());  // "hello"

泛型的使用方法如下：

1. 类型占位符

泛型的基础是类型占位符，用于表示要传入的具体类型。类型占位符一般用单个大写字母表示，例如T、E等。以下是类型占位符的一个简单示例：

public static <T> void printArray(T[] arr) {
    for (T t : arr) {
        System.out.print(t + " ");
    }
}

这个静态方法使用了类型占位符T，表示这个方法可以接受任何类型的数组。该方法的使用示例：

Integer[] intArr = new Integer[]{1, 2, 3};
String[] strArr = new String[]{"hello", "world"};
printArray(intArr);  //1 2 3
printArray(strArr);  //hello world

2. 类型限定

泛型类型可以限定为某个类、接口或其子类、子接口。以下是简单的一次类型限定示例：

public static <T extends Number> void printNumber(T num) {
    System.out.println(num);
}

这个静态方法要求传入的类型必须是Number或其子类，否则会编译错误。该方法的使用示例：

printNumber(10);      //10
printNumber(10.0f);   //10.0

3. 泛型类和泛型接口

我们在前面已经介绍了泛型类的定义和使用方法。泛型接口的定义和使用方法与泛型类类似。以下是一个简单的泛型接口的定义：

public interface GenericInterface<T> {
    public T getValue();
}

这个泛型接口定义了一个getValue方法，返回一个泛型类型T。在使用该接口时，需要传入一个具体的类型。例如：

public class IntegerGenericInterface implements GenericInterface<Integer> {
    public Integer getValue() {
        return 10;
    }
}

4. 泛型方法

泛型方法可以是一个普通方法，也可以是一个静态方法。以下是一个简单的泛型方法的定义：

public static <T> void swap(T[] arr, int i, int j) {
    T temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

这个泛型方法使用了类型占位符T，表示可以接受任何类型的数组。该方法的使用示例：

String[] strArr = new String[]{"hello", "world"};
swap(strArr, 0, 1);
System.out.println(strArr[0]);   //"world"
System.out.println(strArr[1]);   //"hello"

泛型的主要作用是减少代码的重复和类型转换异常，可以让程序员在编码阶段确定数据类型，提高代码的可读性和可维护性。在Java中，一些常见的泛型类和泛型接口已经被预定义好，例如List、Set、Map、Iterator等，可以直接使用。