Java学习笔记（6）泛型

一、泛型

　　Java 泛型（generics）是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型。

泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。

package Java基础.泛型;

import java.util.ArrayList;
import java.util.List;


public class Test {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add(11);
        list.add("11");
        list.add(true);
        System.out.println(list);

        List<String> l = new ArrayList<String>();// 只能输入String类型参数
        l.add("233");
        // 泛型只在编译阶段有效，在编译过程中，正确检验泛型结果后，会将泛型相关信息擦除
        // 并且在对象进入和离开方法的边界处添加类型检查和类型转换方法，泛型信息不会进入运行阶段
//        l.add(true); // 编译不通过，报错

    }
}

二、泛型类、泛型接口、泛型方法

package Java基础.泛型;

import javax.management.ObjectName;

public class Test1 {
    public static void main(String[] args) {

        //泛型类
        AI<String> a1 = new AI<String>();// 在new A的对象指定泛型的类型String
        a1.setKey("xxxx");
        String s = a1.getKey();// T getKey(),返回值就有new对象返回值是String

        AI<Integer> a2 = new AI<Integer>();// 在new A的对象指定泛型的类型String
        a2.setKey(111);
        Integer i = a2.getKey();

        AI a3 = new AI();// 不指定泛型，相当于指定了一个Object类型
//        AI<Object> a3 = new AI<Object>();
        a3.setKey(new Object());
        Object obj = a3.getKey();

        // 同样的类，但是new对象时泛型指定不同的数据类型，这些对象不能相互赋值
//        a1 = a2;   // 会报错

        // 泛型接口
        B1<Object> b1 = new B1<Object>();
        B1<String> b2 = new B1<String>();

        B2 b3 = new B2(); // B2已经指定String类型，不需要new B2<String>()

        //泛型方法
        CC<Object> c = new CC<Object>();
        c.test("xxxx");
        // 泛型方法，在调用之前没有固定的数据类型
        // 在调用时，传入的参数是什么类型，就会把泛型改成什么类型
        Integer i1 = c.test1(2);// 传递的入参是Integer，泛型就固定成Integer,返回值也是Integer
        Boolean b = c.test1(true);
    }
}


/***
 * 泛型类
 * 此次的泛型T可以任意的取名  A B V ，一般使用T  意味着type
 */
class AI<T>{
    private T key;

    public void setKey(T key){
        this.key = key;
    }

    public T getKey(){
        return  this.key;
    }
}

/**
 * 泛型接口
 */
interface IB<T>{
    T test(T t);
}

/*
* 未传入实参时，与泛型类的定义相同，在声明类的时候，需要将泛型的声明一起加到类中
*
* */
class B1<T> implements IB<T>{

    @Override
    public T test(T t) {
        return t;
    }
}

// 如果实现接口时，指定接口的泛型的具体数据类型，这个类实现接口的所有方法的位置都要泛型替换成实际的具体参数类型
class B2 implements IB<String>{

    @Override
    public String test(String s) {
        return s;
    }
}

/**
 * 泛型方法
 */

class CC<E>{
    private E e;

    public  static <T> void test3(T t){ // 静态方法的泛型
        // 在静态方法中，不能使用类定义的泛型，如果要使用泛型，只能使用静态方法定自己定义泛型
        System.out.println(t);
    }

    public <T> void test(T s){ // 无返回值的泛型方法
        System.out.println(this.e);
        T t = s;
    }

    public <T> T test1(T s){ //  有返回值的泛型方法
        return s;
    }

    public <T> void test2(T... strs){ // 形参为可变参数的泛型方法
        for (T s:strs){
            System.out.println(s);
        }
    }
}

/**
 * 泛型通配符
 */