Java方法：泛型的简介

泛型定义

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

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

使用泛型的意义

1.适用于多种数据类型执行相同的代码(代码复用)

未使用泛型前，针对不同的参数类型需要对函数作重载操作

private static int add(int a, int b) {
    System.out.println(a + "+" + b + "=" + (a + b));
    return a + b;
}
private static float add(float a, float b) {
    System.out.println(a + "+" + b + "=" + (a + b));
    return a + b;
}
private static double add(double a, double b) {
    System.out.println(a + "+" + b + "=" + (a + b));
    return a + b;
}

使用泛型后，可以将多种参数类型情况复用为一个函数

private static <T extends Number> double add(T a, T b) {
    System.out.println(a + "+" + b + "=" + (a.doubleValue() + b.doubleValue()));
    return a.doubleValue() + b.doubleValue();
}

泛型的使用情况

1.泛型类

public class TClass {
    public static void main(String[] args) {
        TClass00<String, Object> tClass = new TClass00<>();
        tClass.setKey("hello");
        tClass.setValue("world");
        System.out.println(tClass.getKey() + " " + tClass.getValue());
        tClass.setValue(0.0);
        System.out.println(tClass.getKey() + " " + tClass.getValue());
    }
}
// 泛型类
class TClass00<K, V> {
    private K key;
    private V value;
    public K getKey() {
        System.out.println(key.getClass());
        return key;
    }
    public void setKey(K key) {
        this.key = key;
    }
    public V getValue() {
        System.out.println(value.getClass());
        return value;
    }
    public void setValue(V value) {
        this.value = value;
    }
}

// 输出结果
class java.lang.String
class java.lang.String
hello world
class java.lang.String
class java.lang.Double
hello 0.0

2.泛型接口

public class TImpl {
    public static void main(String[] args) {
        TImpl00<Float> tImpl00 = new TClass00<>();
        tImpl00.hello(0.0f);
    }
}
// 定义泛型接口
interface TImpl00<T> {
    T hello(T t);
}
// 定义接口的子类
class TClass00<T> implements TImpl00<T>{
    @Override
    public T hello(T t) {
        System.out.println(t.getClass());
        System.out.println("hello " + t.toString());
        return t;
    }
}

// 输出结果
class java.lang.Float
hello 0.0

3.泛型方法

public class TMethods {
    public static void main(String[] args) {
        System.out.println("hello".getClass());
        getClass("hello".getClass());
    }    
    /**
     * 定义泛型方法的规则：
     *      1.所有泛型方法声明都有一个类型参数声明部分（由尖括号分隔），该类型参数声明部分在方法返回类型之前
     *      2.每一个类型参数声明部分包含一个或多个类型参数，参数间用逗号隔开。一个泛型参数，也被称为一个类型变量，是用于指定一个泛型类型名称的标识符。
     *      3.类型参数能被用来声明返回值类型，并且能作为泛型方法得到的实际参数类型的占位符。
     *      4.泛型方法体的声明和其他方法一样。注意类型参数只能代表引用型类型，不能是原始类型
     */
    // 泛型方法
    public static <T extends Object> void getClass(T t) {
        System.out.println(t);
        System.out.println(t.getClass());
    }
}

// 输出结果
class java.lang.String
class java.lang.String
class java.lang.Class

泛型的上下限

为了解决泛型中隐含的转换问题，Java泛型加入了类型参数的上下边界机制。

<? extends A>表示该类型参数可以是A(上边界)或者A的子类类型。编译时擦除到类型A，即用A类型代替类型参数。

<? super A>表示该类型参数可以是A(下边界)或者A的父类类型。

public class TClass {
    public static void main(String[] args) {
//        TClass00<String, Object> tClass = new TClass00<>();
//        tClass.setKey("hello");
//        tClass.setValue("world");
//        System.out.println(tClass.getKey() + " " + tClass.getValue());
//        tClass.setValue(0.0);
//        System.out.println(tClass.getKey() + " " + tClass.getValue());
        // 上限
        TClass00<String, Double> hello = new TClass00<>();
        hello.setKey("hello");
        hello.setValue(0.0);
        hello(hello);
        // 下限
        TClass00<String, Object> world = new TClass00<>();
        world.setKey("hello");
        world.setValue("world");
        world(world);
    }
    // 上限
    public static void hello(TClass00<? extends String, ? extends Number> tClass00) {
        System.out.println(tClass00.getKey() + " " + tClass00.getValue());
    }
    // 下限
    public static void world(TClass00<? super String, ? super Integer> tClass00) {
        System.out.println(tClass00.getKey() + " " + tClass00.getValue());
    }
}
// 泛型类
class TClass00<K, V> {
    private K key;
    private V value;
    public K getKey() {
        System.out.println(key.getClass());
        return key;
    }
    public void setKey(K key) {
        this.key = key;
    }
    public V getValue() {
        System.out.println(value.getClass());
        return value;
    }
    public void setValue(V value) {
        this.value = value;
    }
}

// 输出结果
class java.lang.String
class java.lang.Double
hello 0.0
class java.lang.String
class java.lang.String
hello world

以上就是关于“Java方法：泛型的简介”，如果大家对此比较感兴趣，想了解更多相关知识，不妨来关注一下本站的Java泛型详解，里面还有更详细的介绍，相信对大家的学习一定会有所帮助的。