java泛型接口

java泛型接口

泛型接口
格式:
访问权限　interface 接口名<泛型标示>{}

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

class InfoImpl implements Info {
    public String getVar() {
        return null;
    }
}

子类定义泛型的类型

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

class InfoImpl<T> implements Info<T> {
    private T var;
    public InfoImpl(T var) {
        this.setVar(var);
    }
    public void setVar(T var) {
        this.var = var;
    }
    public T getVar() {
        return this.var;
    }
}
public class GenericsDemo24 {
    public static void main(String args[]) {
        Info<String> i = null;
        i = new InfoImpl<String>("123");
        System.out.println("hello: " + i.getVar());
    }
}

另一种实现方式,　子类直接使用具体的类型

interface Info<T>{        // 在接口上定义泛型
    public T getVar() ; // 定义抽象方法，抽象方法的返回值就是泛型类型
}
class InfoImpl implements Info<String>{   // 定义泛型接口的子类
    private String var ;                // 定义属性
    public InfoImpl(String var){        // 通过构造方法设置属性内容
        this.setVar(var) ;
    }
    public void setVar(String var){
        this.var = var ;
    }
    public String getVar(){
        return this.var ;
    }
};
public class GenericsDemo25{
    public static void main(String arsg[]){
        Info i = null;      // 声明接口对象
        i = new InfoImpl("Hello") ;   // 通过子类实例化对象
        System.out.println("内容：" + i.getVar()) ;
    }
};

定义泛型方法

格式:
访问权限 <泛型标识>　泛型标识　方法名称(泛型标识　参数名称)

class Demo{
    public <T> T fun(T t){            // 可以接收任意类型的数据
        return t ;                  // 直接把参数返回
    }
};
public class GenericsDemo26{
    public static void main(String args[]){
        Demo d = new Demo() ;   // 实例化Demo对象
        String str = d.fun("Hello") ; //  传递字符串
        int i = d.fun(30) ;     // 传递数字，自动装箱
        System.out.println(str) ;   // 输出内容
        System.out.println(i) ;     // 输出内容
    }
};

泛型使用中类型推导方式

1. 通过泛型方法返回泛型类的实例

class Info<T extends Number>{ // 指定泛型的类别，只能是数字类型
    private T var ;     // 此类型由外部决定
    public T getVar(){
        return this.var ;
    }
    public void setVar(T var){
        this.var = var ;
    }
    public String toString(){ // 覆写Object类中的toString()方法
        return this.var.toString();
    }
}
public class GenericsDemo27{
    public static void main(String args[]){
        Info<Integer> i = fun(30);
        System.out.println(i.getVar());
    }
    public static <T extends Number> Info<T> fun(T param){
        Info<T> temp = new Info<T>() ;      // 根据传入的数据类型实例化Info
        temp.setVar(param) ;        // 将传递的内容设置到Info对象的var属性之中
        return temp ;   // 返回实例化对象
    }
}

1. 使用泛型统一传入参数的类型

class Info<T>{
    private T var ;     // 此类型由外部决定
    public T getVar(){
        return this.var ;
    }
    public void setVar(T var){
        this.var = var ;
    }
    public String toString(){ // 覆写Object类中的toString()方法
        return this.var.toString();
    }
}
public class GenericsDemo28{
    public static void main(String args[]){
        Info<String> i1 = new Info<String>() ;
        Info<String> i2 = new Info<String>() ;
        i1.setVar("HELLO") ;        // 设置内容
        i2.setVar("WORLD") ;      // 设置内容
        add(i1,i2) ;
    }
    public static <T> void add(Info<T> i1,Info<T> i2){
        System.out.println(i1.getVar() + " " + i2.getVar()) ;
    }
}

1. 如果add方法中两个泛型的类型不统一，则编译会出错。

class Info<T>{
    private T var ;     // 此类型由外部决定
    public T getVar(){
        return this.var ;
    }
    public void setVar(T var){
        this.var = var ;
    }
    public String toString(){       // 覆写Object类中的toString()方法
        return this.var.toString() ;
    }
}
public class GenericsDemo29{
    public static void main(String args[]){
        Info<Integer> i1 = new Info<Integer>() ;
        Info<String> i2 = new Info<String>() ;
        i1.setVar(30) ;     // 设置内容
        i2.setVar("XiaoHua") ;      // 设置内容
        add(i1,i2) ;
    }
    public static <T> void add(Info<T> i1,Info<T> i2){
        System.out.println(i1.getVar() + " " + i2.getVar()) ;
    }
}