JAVA泛型详解

虽然java提供了向上转型和向上转型，有些强制的转型虽然不会被编译器发现，但是会在运行的时候暴露出来。如下图和代码。

public class Main {
    //类的每个单词首字母要大写
    public static void main(String[] args) {
        Student student=new Student();
        Dog dog=new Dog();
        Object o1=student;
        Object o2=dog;
        Student student1=(Student) o2;
        System.out.println(student1);
    }
}
class Student{
    String name;
}
class Dog{
    String name;
}

//定义泛型类
public class OverClass_01<T> {
    //定义泛型变量
    private T over;
    //定义getXXX()方法
    public T getOver() {
        return over;
    }
    //定义setXXX()方法
    public void setOver(T over) {
        this.over = over;
    }
    public static void main(String[] args) {
        //实例化一个Boole型对象
        OverClass_01<Boolean> over1=new OverClass_01<>();
        //实例化一个Float对象
        OverClass_01<Float> over2=new OverClass_01<>();
        //不需要类型转换
        over1.setOver(true);
        over2.setOver(12.3F);
        Boolean b=over1.getOver();
        Float f= over2.getOver();
        System.out.println(b);
        System.out.println(f);
    }
}

public class ArrayClass_02<T> {
    private T[] array;
    public T[] getArray() {
        return array;
    }
    public void setArray(T[] array) {
        this.array = array;
    }
    public static void main(String[] args) {
        ArrayClass_02<String> a=new ArrayClass_02<>();
        String[] array={"成员1","成员2","成员3","成员4","成员5"};
        a.setArray(array);
        for (int i = 0; i < a.getArray().length; i++) {
            System.out.println(a.getArray()[i]);
        }
    }
}

public class MutiOverClass <K,V>{
    //定义一个集合HashMap实例
    public Map<K,V> map=new HashMap<>();
    public void put(K k,V v){
        map.put(k, v);
    }
    public V get(K k){
        return map.get(k);
    }
    public static void main(String[] args) {
        //创建实例对象
        MutiOverClass<Integer,String> mu=new MutiOverClass<>();
        //往集合添加键和值
        for (int i = 0; i < 5; i++) {
            mu.put(i,"我是集合成员"+i);
        }
        //获取集合中键对应的值
        for (int i = 0; i < mu.map.size(); i++) {
            System.out.println(mu.get(i));
        }
    }
}

public class AnyClass {
    public static void main(String[] args) {
        ArrayList<Integer> a=new ArrayList<>();
        a.add(1);
        for (int i = 0; i < a.size(); i++) {
            System.out.println("获取ArrayList容器的值"+a.get(i));
        }
        Vector<String> vector=new Vector<>();
        for (int i = 0; i < 5; i++) {
            vector.addElement("成员"+i);
        }
        for (int i = 0; i < vector.size(); i++) {
            System.out.println("获取Vector容器的值"+vector.get(i));
        }
    }
}

 *  class 类名称<T extends anyClass>
 *     解释：使用泛型限制之后，泛型类的类型都必须实现和继承了anyClass这个接口或者类。
 *     无论anyClass是接口还是类，在进行限制的时候都必须使用extends关键字
 *
 *     泛型总结：
 *      1、泛型的类型参数只能是类类型，不可以是简单类型。
 *      2、泛型的类型的个数可以是多个
 *      3、可以使用extends关键字限制泛型的类型
 *      4、可以使用通配符限制泛型的类型
 *
 */
//限制泛型的类型
public class LimitClass_04 <T extends List>{
    public static void main(String[] args) {
        //只可以实例化已经实现List接口的类
        LimitClass_04<ArrayList> l1=new LimitClass_04<>();
        LimitClass_04<LinkedList> l2=new LimitClass_04<>();
    }
}

1、泛型的类型只能是类类型，不可以是简单类型。
2、泛型的个数是可以有多个。
3、可以使用extends关键字限制泛型的类型。
4、可以使用通配符限制泛型的类型。