Java--泛型

1.泛型总结：

1.1 泛型的类型参数只能是类类型，不可以是简单类型，如A<int>这种泛型定义就是错误的。

1.2 泛型的类型个数可以是多个。

1.3 可以使用extends关键字限制泛型的类型。

1.4 可以使用通配符限制泛型的类型。

2. 定义泛型语法：类名<T>

类名<T>

T代表一个类型的名称；

package myenum;

public class OverClass<T> {     //定义泛型类
    private T over;             //定义泛型成员变量

    public T getOver() {         //设置getXX()方法
        return over;
    }

    public void setOver(T over) {    //设置setXX()方法
        this.over = over;
    }

    public static void main(String[] args) {
        OverClass<Boolean> over1 = new OverClass<Boolean>();    //实例化一个Boolean类型的对象
        OverClass<Float> over2 = new OverClass<Float>();        //实例化一个Float类型的对象

        over1.setOver(true);                //不需要进行类型转换
        over2.setOver(12.3f);

        Boolean b = over1.getOver();        //不需要进行类型转换
        Float f = over2.getOver();

        System.out.println(b);
        System.out.println(f);

    }
}

定义泛型类时，一般类型名称使用【T】来表示，容器的元素使用【E】来表示。 

3.泛型的常规用法

3.1 定义泛型类时声明多个类型

3.1.1 定义

MutiOverClass<T1, T2>

MutiOverClass: 泛型类名称

T2,T2为可能被定义的类型；

3.1.2 实例化

MutiOverClass<Boolean, Float> bf = new MutiOverClass<Boolean, Float>();

3.2 定义泛型类时声明数组类型

package myenum;

import java.util.ArrayList;

public class ArrayClass<T> {
    private T[] array;      //array数组的类型为泛型

    public void setArray(T[] array) {
        this.array = array;
    }

    public T[] getArray() {
        return array;
    }

    public static void main(String[] args) {
        ArrayClass<String> al = new ArrayClass<String>();
        String[] array = {"成员1", "成员2", "成员3", "成员4", "成员5"};
        al.setArray(array);
        for (int i = 0; i < al.getArray().length; i++) {
            System.out.println(al.getArray()[i]);       //调用getArray()方法返回数组中的值
        }
    }
}

//输出：
//        成员1
//        成员2
//        成员3
//        成员4
//        成员5

可以在使用泛型机制时声明数组，但是不能使用泛型来建立数组的实例。

public class ArrayClass<T>{

        //private T[] t = new T[10];                //不能用泛型来建立数组的实例

} 

3.3 集合类声明容器的元素

package myenum;

import java.util.HashMap;

public class MutiOverClass<K, V> {
    HashMap<K, V> hm = new HashMap<K, V>();  //定义一个集合HashMap实例

    //设置set方法，将对应的键值对信息存入结合对象中
    public void setHm(K key, V value) {
        hm.put(key, value);
    }

    public V getHm(K key) {      //根据键名获取键值
        return hm.get(key);
    }

    public static void main(String[] args) {
        MutiOverClass<Integer, String> mu = new MutiOverClass<Integer, String>(); //实例化泛型类对象
        for (int i = 0; i < 5; i++) {
            mu.setHm(i, "我是集合成员" + i);
        }

        for (int j = 0; j < mu.hm.size(); j++) {
            System.out.println(mu.getHm(j));
        }
    }
}

输出：
        我是集合成员0
        我是集合成员1
        我是集合成员2
        我是集合成员3
        我是集合成员4

常用被泛型话的集合类

集合类	泛型定义
ArrayList	ArrayList<E>
HashMap	HashMap<K, V>
HashSet	HashSet<E>
Vector	Vector<E>

package myenum;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Vector;

public class ArrayClass {
    //使用泛型实例化常用集合类
    public static void main(String[] args) {
        //定义ArrayList容器，容器内的元素都是String类型
        ArrayList<Integer> al = new ArrayList<Integer>();
        al.add(1);      //为容器添加新值
        al.add(2);      //为容器添加新值
        for (int a = 0; a < al.size(); a++) {
            System.out.println("获取ArrayList容器内的值：" + al.get(a));
        }

        //定义HashMap容器，设置容器内的键名与键值分别为Interger和String类型
        HashMap<Integer, String> hm = new HashMap<Integer, String>();
        for (int h = 0; h < 3; h++) {
            hm.put(h, "成员" + h);
        }
        for (int m = 0; m < hm.size(); m++) {
            System.out.println("获取hm容器的值是：" + hm.get(m));
        }

        //定义Vector容器，使容器内的内容为String类型
        Vector<String> vc = new Vector<String>();
        for (int v = 0; v < 5; v++) {
            vc.add("成员" + v);
        }
        for (int k = 0; k < vc.size(); k++) {
            System.out.println("获取Vector容器的值：" + vc.get(k));
        }
    }
}

输出：
        获取ArrayList容器内的值：1
        获取ArrayList容器内的值：2
        获取hm容器的值是：成员0
        获取hm容器的值是：成员1
        获取hm容器的值是：成员2
        获取Vector容器的值：成员0
        获取Vector容器的值：成员1
        获取Vector容器的值：成员2
        获取Vector容器的值：成员3
        获取Vector容器的值：成员4

 

4. 泛型的高级用法

4.1 限制泛型可用类型

默认可以使用任何类型来实例化一个泛型类对象。但是也可以对泛型类实例的类型做出限制；

4.1.1 语法：class 类名称<T extends anyClass>

其中，anyClass指某个类或接口；使用泛型限制后，泛型类的类型必须实现这个接口或继承这个类，且使用泛型限制时必须使用【extends】关键字

class LimitClass<T extends List>{

        //someSentence

}

import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;

public class LimitClass<T extends List> {
    public static void main(String[] args) {
        //可以实例化已经实现list接口的类
        LimitClass<ArrayList> l1 = new LimitClass<ArrayList>();
        LimitClass<LinkedList> l2 = new LimitClass<LinkedList>();

        //这句代码有问题，因为HashMap没有实现list接口
//       LimitClass<HashMap> l3 = new LimitClass<HashMap>();
    }
}

4.2 使用类型通配符

在泛型机制中，提供了类型通配符【?】,类型通配符的作用是在创建一个泛型对象时限制这个泛型类的类型实现或继承某个接口或类的子类。同时使用【extends】关键字来对泛型进行限制。

4.2.1 语法：泛型类名称<? extends List> a = null; 

A<? extends List> a = null; 

a = new A<ArrayList>();

a = new A<LinkedList>();

其中，<? extends List>代表类型未知，当需要使用该泛型对象时，可以单独实例化。 

4.3 继承泛型类与实现泛型接口

定义为泛型的类和接口也可以被继承和实现。

4.3.1 继承泛型类

public class ExtendClass<T1>{

        //

}

class SubClass<T1,T2,T3> extends ExtendClass<T1>{

        //

}

4.3.2 继承泛型接口

interface inter<T1>{

        //

}

class SubClass<T1,T2,T3> implements inter<T1>{

        //

}