Java 静态final属性加泛型 java 静态方法 泛型

泛型

泛型简介

1. 泛型可以理解为参数化类型,主要作用在类,方法和接口上。
2. Java泛型 与 C++ 模板 : Java 中的泛型 , 是仿照 C++ 中的模板开发的 , 目的是让开发者可以写出通用,灵活的代码 。
3. 伪泛型 : Java中的泛型 , 是伪泛型 , Java 泛型开发好之后 , 在编译阶段就将泛型相关的信息消除了 , 不会泛型留到运行时。

泛型类型 :

• 泛型方法 : 方法有参数 , 方法的参数 可以指定成一些 泛型 ;
• 泛型类 : 类 也可以有参数 , 将 类型 作为 参数 传入类中 ;
• 泛型接口 : 接口 的 参数 , 也可以是泛型 ;

将类型传入泛型方法 , 泛型类, 泛型接口中 , 可以动态地指定一些类型 ;
泛型的作用 :

• 安全检查 : 在编译阶段 , 就可以进行 代码检查, 将更少的错误带到运行时 ;
• 避免强转 : 避免类型的强转导致不必要的安全问题 ;
• 提高性能 : 使用泛型可以提高 Java 的性能 ;

泛型类

泛型类 : 在类名后面使用声明泛型 , 则在该类中, 可以使用该泛型类型 T 类型 ;特别注意 , 该类中的 如下2个方法不是泛型方法 ; 其中的参数 , 返回值类型是T , 但这个T是作为一个正常的类型使用的 , 并不是声明在方法 中的泛型 ;
如果类,接口,方法是泛型类, 泛型接口,泛型方法, 则该类 , 接口 , 方法必须由 修饰 , 有个带尖括号的 T ;

public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }

完整的泛型类

/**
 * 泛型类
 *  该 T 类型作为参数使用
 *  T 是参数化类型 , 可以由外部传入
 *
 * @param <T>
 */
public class Student<T> {

    private String name;
    private int age;
    /**
     * 该数据的类型未知
     *  使用泛型表示 , 运行时确定该类型
     */
    private T data;

    public Student(String name, int age, T data) {
        this.name = name;
        this.age = age;
        this.data = data;
    }

    /**
     * 该方法不是泛型方法
     *  该方法是普通方法 , 返回值类型是 T 类型
     * @return
     */
    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }
}

泛型方法

泛型方法 : 在方法的返回值前, 使用 声明泛型的方法 , 是泛型方法 ; 将某个类型作为参数传入 ;
泛型个数 : 该方法是泛型方法, 且指定了2个泛型 , 泛型的个数可以有很多个, 多个泛型之间 , 使用逗号隔开 ;
泛型方法 与 泛型类 中的泛型 :
泛型不同 : 泛型方法指定的泛型T与 类中的泛型T没有任何关系 , 这两个T 可以是不同的类型 ;
泛型相同 : 泛型方法中定义的泛型T , 与参数类型的T , 返回值类型的T , 方法内部的T , 都是同一个类型 ;

/**
 * 泛型类
 *  该 T 类型作为参数使用
 *  T 是参数化类型 , 可以由外部传入
 *
 * @param <T>
 */
public class Student<T> {

    private String name;
    private int age;
    /**
     * 该数据的类型未知
     *  使用泛型表示 , 运行时确定该类型
     */
    private T data;

    public Student(String name, int age, T data) {
        this.name = name;
        this.age = age;
        this.data = data;
    }

    /**
     * 泛型方法 , 是将某个类型作为参数传入
     *      方法指定泛型 , 写法如下
     *
     * 该方法是泛型方法
     *      方法指定了 2 个泛型
     *      泛型个数 , 泛型的个数可以有很多个
     *      多个泛型之间 , 使用逗号隔开
     *
     * 为方法指定的泛型 T 与类中的泛型 T 没有任何关系
     *      这两个 T 可以是不同的类型
     *
     * 泛型方法中定义的泛型 T
     *      与参数类型的 T
     *      返回值类型的 T
     *      方法内部的 T
     *      都是同一个类型
     *
     * 与泛型类中的 T 完全没有关系
     *
     * @param <T>
     * @param <A>
     * @return
     */
    public <T, A> T getData2(T arg){
        T data = arg;
        return data;
    }
}

静态方法的泛型

静态方法泛型 : 如果静态方法中使用了类中的泛型T, 作为参数或返回值 , 这种使用时错误的 ;

如果必须在静态方法中使用泛型T, 则该泛型T必须是静态方法的泛型 , 不能是类的泛型 ;

错误用法：

正确用法 :

泛型类与泛型方法完整示例

/**
 * 泛型类
 *  该 T 类型作为参数使用
 *  T 是参数化类型 , 可以由外部传入
 *
 * @param <T>
 */
public class Student<T> {

    private String name;
    private int age;
    /**
     * 该数据的类型未知
     *  使用泛型表示 , 运行时确定该类型
     */
    private T data;

    public Student(String name, int age, T data) {
        this.name = name;
        this.age = age;
        this.data = data;
    }

    /**
     * 该方法不是泛型方法
     *  该方法是普通方法 , 返回值类型是 T 类型
     * @return
     */
    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }

    /**
     * 泛型方法 , 是将某个类型作为参数传入
     *      方法指定泛型 , 写法如下 ;
     *
     * 该方法是泛型方法
     *      方法指定了 2 个泛型
     *      泛型个数 , 泛型的个数可以有很多个
     *      多个泛型之间 , 使用逗号隔开
     *
     * 泛型方法指定的泛型 T 与类中的泛型 T 没有任何关系
     *      这两个 T 可以是不同的类型
     *
     * 泛型方法中定义的泛型 T
     *      与参数类型的 T
     *      返回值类型的 T
     *      方法内部的 T
     *      都是同一个类型
     *
     * 与泛型类中的 T 完全没有关系
     *
     * @param <T>
     * @param <A>
     * @return
     */
    public <T, A> T getData2(T arg){
        T data = arg;
        return data;
    }

    /**
     * 如果静态方法中使用类 类中的泛型
     *      这种使用时错误的
     *
     * 如果必须在 静态方法 中使用泛型 T
     *      则该泛型 T 必须是静态方法的泛型
     *      不能是类的泛型
     *
     * @param arg
     * @return
     */
    public static <T> T getData3(T arg){
        T data = arg;
        return data;
    }
}