JAVA基础（二）泛型

一. 在没有泛型时

又时我们在编写方法时，参数的类型尚不能确定，而只能在实例化对象时才确定参数类型，也就是说定义时还不确定，只有使用时才可以确定参数的类型。举个例子，一个学生的成绩可以被表示为整型，字符串类型，也可能是浮点数，在没有泛型时，学生类的定义如下：

package com.fanxing;

/**
 * Student可以接受任意类型，因为发生了多态
 */
public class Student {
    private Object chinese;
    private Object english;

    public Student(Object chinese,Object english){
        super();
        this.chinese = chinese;
        this.english = english;
    }

    public Object getChinese() {
        return chinese;
    }

    public Object getEnglish() {
        return english;
    }

    public void setChinese(Object chinese) {
        this.chinese = chinese;
    }

    public void setEnglish(Object english) {
        this.english = english;
    }
}

入口方法：

package com.fanxing;

/**
 * 获取值：
 * 1.强制类型转换
 * 2.类型检查：避免出现转换错误 java.lang.ClassCastException
 */
public class App {
    public static void main(String[] args){
        //存入整数int---->Integer(自动装箱)---->Object
        Student st=new Student("80","90");

        //String a = (String) st.getJavase();--->强制类型转换可能出现转换错误
        String chineseScore = null;
        int englishScore = 0;

        if (st.getChinese() instanceof String){
            chineseScore = (String)st.getChinese();
        }
        if (st.getEnglish() instanceof Integer){
            englishScore = (int)st.getEnglish();
        }

        System.out.println("englishScore:"+englishScore+",chineseScore:"+chineseScore);

    }
}

运行结果为：englishScore:0,chineseScore:80

二. 泛型的概念

参数化类型，即在类，接口和方法的定义过程中，操作的数据类型由传入的参数指定。JAVA泛型机制被广泛地应用在集合框架中。所有的集合类型都带有泛型参数，这样在创建集合时可以指定放入集合中的对象类型。JAVA编译器可以依据此类型进行类型检查，以减少代码在运行时出现错误的可能。

如下图所示，在声明ArrayList时，类名右侧有一个<E>。"<>"表示泛型，我们可以使用数字，字母或者下划线表示泛型的名字。（通常使用一个大写字母来表示，当然这不是规定）。这时，在此类中声明的方法的参数，以及返回值类型可以被定义为泛型。在创建对象时，就可以将类型作为参数传递，类定义中的所有E将被替换为传入的参数。

三. 泛型的应用示例

（1）泛型类

package com.fanxing2;

/**
 * @param <T1>
 * @param <T2>
 * 泛型类：声明时使用泛型
 * 一般的约定，不是必须：
 *  (1)T：type表示类型
 *  (2)K V: 分别表示键、值中的Key和Values
 *  (3)E: 代表Element
 * 使用时确定类型
 * 注意：
 *  (1)泛型只能使用引用类型，不能使用基本类型；
 *  (2)在泛型类中，泛型不能使用在静态属性和静态方法中；----》因为只有在泛型类实例化后，类型才可以确定
 */
public class Student<T1,T2> {
    //定义时使用泛型
    private T1 englishScore;
    private T2 chineseScore;

    public T1 getEnglishScore() {
        return englishScore;
    }

    public T2 getChineseScore() {
        return chineseScore;
    }

    public void setChineseScore(T2 chineseScore) {
        this.chineseScore = chineseScore;
    }

    public void setEnglishScore(T1 englishScore) {
        this.englishScore = englishScore;
    }

    public static void main(String[] args){
        //使用时指定类型(必须是引用类型，不可以是int...等基本类型)
        Student<String, Integer> st=new Student<String, Integer>();
        //1.安全：类型检查
        st.setChineseScore(100);
        st.setEnglishScore("200");
        //2.省心：类型转换
        Integer chineseScore=st.getChineseScore();
        String englishScore=st.getEnglishScore();

        System.out.println(chineseScore+","+englishScore);
    }
}

（2）泛型接口

package com.fanxing3;

/**
 * 接口中，泛型只能使用在方法中，不能用于全局常量
 * @param <T>
 */
public interface Output<T> {
    String TISHI = "Hello!";
    void Output(T message);
}

（3）泛型方法

package com.fanxing3;

/**
 * 泛型方法：只能访问对象的信息，不能修改对象的信息（因为类型不确定）
 */
public class FanXingMethod {
    public static <T> void Test(T a){
        System.out.println(a);
    }

    public static void main(String[] args){
        FanXingMethod.Test("调用泛型方法！");
    }
}

四. 总结

泛型的概念：类型参数化
起源：数据类型不明确

装入的数据类型都被当做Object对待，从而丢失自己的实际类型。
获取数据时往往需要转型，效率低，且容易产生错误。

泛型的优势

安全：在编译时检查类型；
省心：所有的强制类型转换都是自动和隐式的，提高代码的重用率。

JAVA基础（二）泛型

一. 在没有泛型时

二. 泛型的概念

三. 泛型的应用示例

四. 总结

猜你喜欢