这是我参与2022首次更文挑战的第10天，活动详情查看：2022首次更文挑战

Java程序设计 泛型【二】

泛型接口

[访问权限] interface 接口名称<泛型标识>{
}

interface Info<T>{
}

方法一 在子类的定义上声明泛型类型

interface Info<T>{
    public T getVar();
}
class Infolmpl<T> implements  Info<T>{
    private T var;
    public Infolmpl(T var){
        this.setVar(var);
    }

    public void setVar(T var) {
        this.var = var;
    }

    @Override
    public T getVar() {
        return var;
    }
}
public class Hello {
    public static void main(String[] args) {
        Info<String> i = new Infolmpl<String>("ABC");
        System.out.println(i.getVar());
    }
}

方法二 直接在接口中指定具体类型

interface Info<T>{
    public T getVar();
}
class Infolmpl implements Info<String>{
    private String var;
    public Infolmpl(String var){
        this.setVar(var);
    }

    public void setVar(String var) {
        this.var = var;
    }

    @Override
    public String getVar() {
        return var;
    }
}
public class Hello {
    public static void main(String[] args) {
        Info<String> i = new Infolmpl("ABC");
        System.out.println(i.getVar());
    }
}

直接在实现的接口处指定了具体的泛型类型String，这样在覆写Info接口中的getVar()方法时直接指明类型为String即可

泛型方法

定义语法

[访问权限]<泛型标识> 泛型标识 方法名称([泛型标识 参数名称])

定义泛型方法

将接收的参数直接返回，而且因为在方法接收参数中使用了泛型操作，所以此方法可以接收任意类型的数据，而且此方法的返回值类型将由泛型指定

class Test{
    public <T> T fun(T t){
        return t;
    }
}
public class Hello {
    public static void main(String[] args) {
        Test d = new Test();
        int a = d.fun(45);
        String s = d.fun("ABC");
        System.out.println(a);
        System.out.println(s);
    }
}

通过方法返回泛型类实例

class Info<T extends Number>{
    private T var;

    public T getVar() {
        return var;
    }

    public void setVar(T var) {
        this.var = var;
    }
    public String toString(){
        return this.var.toString();
    }
}
public class Hello {
    public static void main(String[] args) {
        Info<Integer> a = fun(50);
        System.out.println(a.getVar());
    }
    public static <T extends Number> Info<T> fun(T a){
        Info<T> temp = new Info<T>();
        temp.setVar(a);
        return temp;
    }
}

使用泛型统一传入的类型

​

class Info<T>{
    private T var;

    public T getVar() {
        return var;
    }

    public void setVar(T var) {
        this.var = var;
    }
    public String toString(){
        return this.var.toString();
    }
}
public class Hello {
    public static void main(String[] args) {
        Info<Integer> a =new Info<Integer>();
        Info<Integer> b =new Info<Integer>();
        a.setVar(45);
        b.setVar(56);
        sum(a,b);
    }
    public static <T> void sum(Info<T> a,Info<T>b){
        System.out.println(a);
        System.out.println(b);
    }
}

传入其他类型数据则报错

泛型数组

public class Hello {
    public static void main(String[] args) {
        String s[] = f1("A","B","C");
        f2(s);
    }
    public static <T> T[] f1(T...a){
        return a;
    }
    public static <T> void f2(T param[]){
        for(T t : param){
            System.out.println(t);
        }
    }
}