首先,爲什麼會出現泛型。這個動機就是如果是類型錯誤,那麼在編譯的時候就會被捕獲,而不是運行時當作ClassCastException在debug裏面出現,所以將類型的檢查從運行時移到編譯時,有助於找到程序中的錯誤,提高程序的可靠性。
泛型使用在3個地方,類、接口、方法的創建中,相對應的爲泛型類、泛型接口、泛型方法。也就是說泛型是對於類型的通用性。不能將多態的概念混淆進來,二個沒有直接的關係,一個是針對對象的,泛型是針對類的。
接下來是關於泛型概念的幾個例子,涵蓋了泛型的應用。
1.泛型類和泛型的構造
/**
* 泛型類
*
* @author Administrator
*
* @param <T>
* name
* @param <V>
* age
*/
public class Person<T, V> {
private T name;
private V age;
/**
* 泛型類的構造方法定義
*/
public Person(T name, V age) {
this.name = name;
this.age = age;
}
public Person() {
}
public T getName() {
return name;
}
public void setName(T name) {
this.name = name;
}
public V getAge() {
return age;
}
public void setAge(V age) {
this.age = age;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
}
2.泛型方法
/**
* p是傳入進來的,那麼在創建p對象的時候,已經有了具體的類型,那麼在這邊還不知道p中的類型,那麼用?去通配
* @param p
*/
public static void function(Person<?, ?> p) {
System.out.println(p.toString());
}
泛型上限
/**
* 泛型上限
* @param p
*/
public static void function(Person<? extends String, ? extends Integer> p) {
System.out.println(p.toString());
}
泛型下限/**
* 泛型下限
* @param p
*/
public static void function(Person<? super String, ? super Integer> p) {
//此處時能用String或者object
System.out.println(p.toString());
}
main函數
public static void main(String[] args) {
Person<String, Integer> p = new Person<String, Integer>("kwj", 24);
function(p);
}
3.泛型接口
</pre><pre name="code" class="java">public interface DoSomething<T> {
void doSomething(T t);
}
結果
public class Play<T> implements DoSomething<T> {
@Override
public void doSomething(T t) {
System.out.println(t.getClass() + "~~~~~" + t.toString());
}
public static void main(String[] args) {
Play<String> p = new Play<String>();
p.doSomething("i am String");
}
}
另一種寫法
public class Play implements DoSomething<String> {
public static void main(String[] args) {
Play p = new Play();
p.doSomething("i am String");
}
@Override
public void doSomething(String t) {
<pre name="code" class="java"> System.out.println(t.toString());
}}