泛型是jdk1.5使用的新特性。
泛型的好处：
- 将运行时的异常提前至了编译时。
- 避免了无谓的强制类型转换 。
泛型在集合中的常见应用：
ArrayList<String> list = new ArrayList<String>(); true 推荐使用。
ArrayList<Object> list = new ArrayList<String>(); false 前后类型不一致
ArrayList<String> list = new ArrayList<Object>(); false 前后类型不一致
//以下两种写法主要是为了兼顾新老系统的兼用性问题。
ArrayList<String> list = new ArrayList(); true
ArrayList list = new ArrayList<String>(); true
注意：
- 泛型没有多态的概念，左右两边的数据 类型必须 要一致，或者只是写一边的泛型类型。
- 基本数据类型是没有泛型这个概念的
推荐使用： 两边都写泛型。
需求：
把一个集合中元素全部转成大写。
public class Demo1 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<String>(); //<String> 表示该容器只能存储字符串类型 的数据。
list.add("aa");
list.add("bb");
list.add("cc");
for(int i = 0 ; i < list.size() ; i++){
String str = list.get(i);
System.out.println("大写："+ str.toUpperCase());
}
/**
与老系统的兼容测试
*/
MyUtil.print(list);
ArrayList<String> list2 = MyUtil.getList();
}
}
//是老程序员写 的。 jdk1.4的时候写的。
class MyUtil {
public static ArrayList getList(){
return new ArrayList();//接收的引用可能使用了泛型
}
public static void print(ArrayList list){//传过来的对象可能使用了泛型
for (int i = 0; i < list.size() ; i++) {
System.out.println(list.get(i));
}
}
}
泛型类：
泛型类的定义格式：
class 类名<声明自定义泛型>{
}
泛型类要注意的事项：
- 在类上自定义泛型的具体数据类型是在使用该类的时候创建对象时候确定的。
- 如果一个类在类上已经声明了自定义泛型，如果使用该类创建对象 的时候没有指定 泛型的具体数据类型，那么默认为Object类型
- 在类上自定义泛型不能作用于静态的方法，如果静态的方法需要使用自定义泛型，那么需要在方法上自己声明使用。
需求： 编写一个数组 的工具类
class MyArrays<T>{
//元素翻转
public void reverse(T[] arr){ //这样方法就不需要做泛型的声明了 public <T>void reverse(T[] arr)
for(int startIndex = 0, endIndex = arr.length-1 ; startIndex<endIndex ; startIndex++,endIndex--){
T temp = arr[startIndex];
arr[startIndex] = arr[endIndex];
arr[endIndex] = temp;
}
}
public String toString(T[] arr){
StringBuilder sb = new StringBuilder();
for(int i = 0 ; i < arr.length ; i++){
if(i==0){
sb.append("["+arr[i]+",");
}else if(i==arr.length-1){
sb.append(arr[i]+"]");
}else{
sb.append(arr[i]+",");
}
}
return sb.toString();
}
public static <T>void print(T[] t){ //静态方法如果要使用泛型,还是需要做泛型声明
}
}
public class Demo3 {
public static void main(String[] args) {
Integer[] arr = {10,12,14,19};
MyArrays<Integer> tool = new MyArrays<Integer>();
tool.reverse(arr);
System.out.println("数组的元素："+tool.toString(arr));
MyArrays<String> tool2 = new MyArrays<String>();
String[] arr2 = {"aaa","bbb","ccc"};
tool2.reverse(arr2);
ArrayList<String> list = new ArrayList<String>();
}
}
泛型接口
泛型接口的定义格式:
interface 接口名<声明自定义泛型>{
}
泛型接口要注意的事项：
- 接口上自定义的泛型的具体数据类型是在实现一个接口的时候指定的。
- 在接口上自定义的泛型如果在实现接口的时候没有指定具体的数据类型，那么默认为Object类型。
需求： 目前我实现一个接口的时候，我还不明确我目前要操作的数据类型，我要等待创建接口实现类 对象的时候我才能指定泛型的具体数据类型。
如果要延长接口自定义泛型 的具体数据类型，那么格式如下：
public class Demo4<T> implements Dao<T>{
}
interface Dao<T>{
public void add(T t);
}
//public class Demo4 implement Dao<String>//在实现这个接口的时候就指定泛型类型
public class Demo4<T> implements Dao<T> { //现在实现接口的时候我还不想指定这个泛型类型,想在实例化该类的时候再指定;
public static void main(String[] args) {
Demo4<String> d = new Demo4<String>();
}
public void add(T t){
}
}
泛型的上下限：
需求1： 定义一个函数可以接收接收任意类型的集合对象， 要求接收的集合对象只能存储Integer或者是Integer的父类类型数据。
需求2： 定义一个函数可以接收接收任意类型的集合对象， 要求接收的集合对象只能存储Number或者是Number的子类类型数据。
泛型中通配符： ？
? super Integer : 只能存储Integer或者是Integer父类元素。 泛型 的下限
? extends Number ： 只能存储Number或者是Number类型的子类数据。 泛型上限
public class Demo5 {
public static void main(String[] args) {
ArrayList<Integer> list1 = new ArrayList<Integer>();
ArrayList<Number> list2 = new ArrayList<Number>();
HashSet<String> set = new HashSet<String>();
//getData(set);
}
//泛型的上限
public static void getData(Collection<? extends Number> c){
}
//泛型的下限
public static void print(Collection<? super Integer> c){
}
}
