Java中集合的泛型指定及泛型的自定义-蒲公英云

Java中集合的泛型指定及泛型的自定义

关于jdk5.0之后的新特性：泛型机制

1、泛型这种语法机制，只是在程序编译阶段给编译器看的，运行阶段不起作用。

2、泛型在集合中的作用：
当用集合中使用泛型指定之后，说明该集合只能存储这种类型的元素，当你想存储其他元素的时候，编译器会报错。

3、为什么在集合中使用泛型？
因为大多数情况下，我们只会在集合中存储同一类型的对象。

测试代码：

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class Test09 { 
    public static void main(String[] args) { 
        // 创建集合对象，不使用泛型的情况下，分析程序
        List myList = new ArrayList(20);
        // 准备对象元素
        Bird b = new Bird();
        Dog d = new Dog();
        int i = 100;
        String str = "hello";
        // 添加元素
        myList.add(b);
        myList.add(d);
        myList.add(i);
        myList.add(str);
        System.out.println(myList.size());  // 4
        // 遍历集合对象，让动物对象调用移动方法
        Iterator it = myList.iterator();
        while (it.hasNext()) { 
            Object obj = it.next();
            // 你不知道对象是什么类型，所以只能判断是不是动物
            if (obj instanceof Animal) { 
                Animal animal = (Animal)obj;
                animal.move();
            }
        }
        // 当使用泛型之后
        List<Animal> list = new ArrayList<Animal>(20);
        //list.add(1);
        //list.add("abc"); // 编译器报错，说list只能存储Animal类型
        Bird b1 = new Bird();
        Dog d1 = new Dog();
        list.add(b1);
        list.add(d1);
        System.out.println(list.size());  // 2
        Iterator<Animal> it1 =list.iterator();  // 同样给编译器看，我用泛型指定了，只迭代Animal类型
        while (it1.hasNext()) { 
            // 这里取出的元素只能是Animal了
            it1.next().move();
        }
    }
}
class Animal { 
    public void move() { 
        System.out.println("动物在移动！");
    }
}
class Dog extends Animal { 
    public void move() { 
        System.out.println("狗狗在跑步！");
    }
}
class Bird extends Animal { 
    public void move() { 
        System.out.println("鸟儿在飞翔！");
    }
}

4、jdk8之后，泛型有自动推断类型功能（又被称为：钻石表达式，因为“<>”看起来像钻石）

例如：

List<E> list = new ArrayList<>();

后面<>中可以不用写类型，系统会推断出来是E类型。

5、泛型可以自定义吗？可以。

如何自定义泛型？

测试代码：

public class Test10 { 
    public static void main(String[] args) { 
        MyGenericity<String> mg = new MyGenericity<String>();  // 指定为String类型
        mg.doSome("hello");
        //mg.doSome(1); // 编译报错，类型不匹配
        String str = mg.doOther();  // 返回指定类型String
        //MyGenericity<int> mg1 = new MyGenericity<int>(); // 注意，只能指定引用类型
        MyGenericity<Integer> mg1 = new MyGenericity<Integer>();  // 指定Integer类型
        mg1.doSome(10);
        //mg1.doSome("hello"); // 编译报错，类型不匹配
        Integer i = mg1.doOther();  // 返回指定类型Integer
        MyGenericity mg2 = new MyGenericity();  // 这里没有指定类型，默认为Object
        mg2.doSome(new Object());  // 这里可以传所有引用类型了
        Object obj = mg2.doOther();
    }
}
class MyGenericity<Abcd> {   // Abcd是标识符，可以随便写，一般写成“E”或者“T”
    public void doSome(Abcd a) {   // 指定了传Abcd型
        System.out.println(a.toString());
    }
    public Abcd doOther() {   // 返回指定类型
        return null;
    }
}