繼承—泛型
1. 概述
在引入範型以前，Java類型分爲原始類型、複雜類型，其中複雜類型分爲數組和類。引入範型後，一個複雜類型
就能夠在細分紅更多的類型。
例如原先的類型List，如今在細分紅List<Object>, List<String>等更多的類型。
注意，如今List<Object>, List<String>是兩種不一樣的類型，
他們之間沒有繼承關係，即便String繼承了Object。下面的代碼是非法的
List<String> ls = new ArrayList<String>();
List<Object> lo = ls;
這樣設計的緣由在於，根據lo的聲明，編譯器容許你向lo中添加任意對象（例如Integer），可是此對象是
List<String>，破壞了數據類型的完整性。
在引入範型以前，要在類中的方法支持多個數據類型，就須要對方法進行重載，在引入範型後，能夠解決此問題
（多態），更進一步能夠定義多個參數以及返回值之間的關係。
例如
public void write(Integer i, Integer[] ia);
public void write(Double d, Double[] da);
的範型版本爲
public <T> void write(T t, T[] ta);
2. 定義&使用
類型參數的命名風格爲：
推薦你用簡練的名字做爲形式類型參數的名字(若是可能，單個字符)。最好避免小寫字母，這使它和其餘的普通
的形式參數很容易被區分開來。
使用T表明類型，不管什麼時候都沒有比這更具體的類型來區分它。這常常見於泛型方法。若是有多個類型參數，咱們
可能使用字母表中T的臨近的字母，好比S。
若是一個泛型函數在一個泛型類裏面出現，最好避免在方法的類型參數和類的類型參數中使用一樣的名字來避免混
淆。對內部類也是一樣。
2.1 定義帶類型參數的類
在定義帶類型參數的類時，在緊跟類命以後的<>內,指定一個或多個類型參數的名字，同時也能夠對類型參數的取
值範圍進行限定，多個類型參數之間用,號分隔。
定義完類型參數後，能夠在定義位置以後的類的幾乎任意地方（靜態塊，靜態屬性，靜態方法除外）使用類型參數，
就像使用普通的類型同樣。
注意，父類定義的類型參數不能被子類繼承。
public class TestClassDefine<T, S extends T> {
....
}
2.2 定義待類型參數方法
在定義帶類型參數的方法時，在緊跟可見範圍修飾（例如public）以後的<>內,指定一個或多個類型參數的名字，
同時也能夠對類型參數的取值範圍進行限定，多個類型參數之間用,號分隔。
定義完類型參數後，能夠在定義位置以後的方法的任意地方使用類型參數，就像使用普通的類型同樣。
例如：
public <T, S extends T> T testGenericMethodDefine(T t, S s){
...
}
注意：定義帶類型參數的方法，騎主要目的是爲了表達多個參數以及返回值之間的關係。例如本例子中T和S的繼
承關係， 返回值的類型和第一個類型參數的值相同。
若是僅僅是想實現多態，請優先使用通配符解決。通配符的內容見下面章節。
public <T> void testGenericMethodDefine2(List<T> s){
...
}
應改成
public void testGenericMethodDefine2(List<？> s){
...
}
3. 類型參數賦值
當對類或方法的類型參數進行賦值時，要求對全部的類型參數進行賦值。不然，將獲得一個編譯錯誤。
3.1 對帶類型參數的類進行類型參數賦值
對帶類型參數的類進行類型參數賦值有兩種方式
第一聲明類變量或者實例化時。例如
List<String> list;
list = new ArrayList<String>;
第二繼承類或者實現接口時。例如
public class MyList<E> extends ArrayList<E> implements List<E> {...}
3.2 對帶類型參數方法進行賦值
當調用範型方法時，編譯器自動對類型參數進行賦值，當不能成功賦值時報編譯錯誤。例如
public <T> T testGenericMethodDefine3(T t, List<T> list){
...
}
public <T> T testGenericMethodDefine4(List<T> list1, List<T> list2){
...
}
Number n = null;
Integer i = null;
Object o = null;
testGenericMethodDefine(n, i);//此時T爲Number, S爲Integer
testGenericMethodDefine(o, i);//T爲Object, S爲Integer
List<Number> list1 = null;
testGenericMethodDefine3(i, list1)//此時T爲Number
List<Integer> list2 = null;
testGenericMethodDefine4(list1, list2)//編譯報錯
3.3 通配符
在上面兩小節中，對是類型參數賦予具體的值，除此，還能夠對類型參數賦予不肯定值。例如
List<?> unknownList;
List<? extends Number> unknownNumberList;
List<? super Integer> unknownBaseLineIntgerList;
注意： 在Java集合框架中，對於參數值是未知類型的容器類，只能讀取其中元素，不能像其中添加元素，
由於，其類型是未知，因此編譯器沒法識別添加元素的類型和容器的類型是否兼容，惟一的例外是NULL
List<String> listString;
List<?> unknownList2 = listString;
unknownList = unknownList2;
listString = unknownList;//編譯錯誤
4. 數組範型
可使用帶範型參數值的類聲明數組，卻不可有建立數組
List<Integer>[] iListArray;
new ArrayList<Integer>[10];//編譯時錯誤
5. 實現原理
5.1. Java範型時編譯時技術，在運行時不包含範型信息，僅僅Class的實例中包含了類型參數的定義信息。
泛型是經過java編譯器的稱爲擦除(erasure)的前端處理來實現的。你能夠（基本上就是）把它認爲是一個從源
碼到源碼的轉換，它把泛型版本轉換成非泛型版本。
基本上，擦除去掉了全部的泛型類型信息。全部在尖括號之間的類型信息都被扔掉了，所以，好比說一個
List<String>類型被轉換爲List。全部對類型變量的引用被替換成類型變量的上限(一般是Object)。並且，
不管什麼時候結果代碼類型不正確，會插入一個到合適類型的轉換。
<T> T badCast(T t, Object o) {
return (T) o; // unchecked warning
}
類型參數在運行時並不存在。這意味着它們不會添加任何的時間或者空間上的負擔，這很好。不幸的是，這也意味
着你不能依靠他們進行類型轉換。
5.2.一個泛型類被其全部調用共享
下面的代碼打印的結果是什麼？
List<String> l1 = new ArrayList<String>();
List<Integer> l2 = new ArrayList<Integer>();
System.out.println(l1.getClass() == l2.getClass());
或許你會說false，可是你想錯了。它打印出true。由於一個泛型類的全部實例在運行時具備相同的運行時類(class)，
而無論他們的實際類型參數。
事實上，泛型之因此叫泛型，就是由於它對全部其可能的類型參數，有一樣的行爲；一樣的類能夠被看成許多不一樣
的類型。做爲一個結果，類的靜態變量和方法也在全部的實例間共享。這就是爲何在靜態方法或靜態初始化代碼
中或者在靜態變量的聲明和初始化時使用類型參數（類型參數是屬於具體實例的）是不合法的緣由。
5.3. 轉型和instanceof
泛型類被全部其實例(instances)共享的另外一個暗示是檢查一個實例是否是一個特定類型的泛型類是沒有意義的。
Collection cs = new ArrayList<String>();
if (cs instanceof Collection<String>) { ...} // 非法
相似的，以下的類型轉換
Collection<String> cstr = (Collection<String>) cs;
獲得一個unchecked warning，由於運行時環境不會爲你做這樣的檢查。
6. Class的範型處理
Java 5以後，Class變成範型化了。
JDK1.5中一個變化是類 java.lang.Class是泛型化的。這是把泛型擴展到容器類以外的一個頗有意思的例子。
如今，Class有一個類型參數T, 你極可能會問，T 表明什麼？它表明Class對象表明的類型。好比說，
String.class類型表明 Class<String>，Serializable.class表明 Class<Serializable>。
這能夠被用來提升你的反射代碼的類型安全。
特別的，由於 Class的 newInstance() 方法如今返回一個T, 你能夠在使用反射建立對象時獲得更精確的類型。
好比說，假定你要寫一個工具方法來進行一個數據庫查詢，給定一個SQL語句，並返回一個數據庫中符合查詢條件
的對象集合(collection)。
一個方法是顯式的傳遞一個工廠對象，像下面的代碼：
interface Factory<T> {
public T[] make();
}
public <T> Collection<T> select(Factory<T> factory, String statement) {
Collection<T> result = new ArrayList<T>();
/* run sql query using jdbc */
for ( int i=0; i<10; i++ ) { /* iterate over jdbc results */
T item = factory.make();
/* use reflection and set all of item’s fields from sql results */
result.add( item );
}
return result;
}
你能夠這樣調用：
select(new Factory<EmpInfo>(){
public EmpInfo make() {
return new EmpInfo();
}
} , 」selection string」);
也能夠聲明一個類 EmpInfoFactory 來支持接口 Factory：
class EmpInfoFactory implements Factory<EmpInfo> { ...
public EmpInfo make() { return new EmpInfo();}
}
而後調用：
select(getMyEmpInfoFactory(), "selection string");
這個解決方案的缺點是它須要下面的兩者之一：
調用處那冗長的匿名工廠類，或爲每一個要使用的類型聲明一個工廠類並傳遞其對象給調用的地方
這很不天然。
使用class類型參數值是很是天然的，它能夠被反射使用。沒有泛型的代碼多是：
Collection emps = sqlUtility.select(EmpInfo.class, 」select * from emps」); ...
public static Collection select(Class c, String sqlStatement) {
Collection result = new ArrayList();
/* run sql query using jdbc */
for ( /* iterate over jdbc results */ ) {
Object item = c.newInstance();
/* use reflection and set all of item’s fields from sql results */
result.add(item);
}
return result;
}
可是這不能給咱們返回一個咱們要的精確類型的集合。如今Class是泛型的，咱們能夠寫：
Collection<EmpInfo> emps=sqlUtility.select(EmpInfo.class, 」select * from emps」); ...
public static <T> Collection<T> select(Class<T>c, String sqlStatement) {
Collection<T> result = new ArrayList<T>();
/* run sql query using jdbc */
for ( /* iterate over jdbc results */ ) {
T item = c.newInstance();
/* use reflection and set all of item’s fields from sql results */
result.add(item);
}
return result;
}
來經過一種類型安全的方式獲得咱們要的集合。
這項技術是一個很是有用的技巧，它已成爲一個在處理註釋(annotations)的新API中被普遍使用的習慣用法。
7. 新老代碼兼容
7.1. 爲了保證代碼的兼容性，下面的代碼編譯器（javac）容許，類型安全有你本身保證
List l = new ArrayList<String>();
List<String> l = new ArrayList();
7.2. 在將你的類庫升級爲範型版本時，慎用協變式返回值。
例如，將代碼
public class Foo {
public Foo create(){
return new Foo();
}
}
public class Bar extends Foo {
public Foo create(){
return new Bar();
}
}
採用協變式返回值風格，將Bar修改成
public class Bar extends Foo {
public Bar create(){
return new Bar();
}
}前端
- 中文名
- 泛型
- 外文名
- genericity
- 類 別
- 程序設計語言的一種特性
- 適用範圍
- 計算機
泛型約束
泛型約束
|
// type parameter T in angle bracketspublicclass
public class GenericList<T>
{
// The nested class is also generic on T
private class Node
{
// T used in non-generic constructor
public Node(T t)
{
next = null;
data = t;
}
private Node next;
public Node Next
{
get { return next; } set { next = value; }
}
// T as private member data type
private T data;
// T as return type of property
public T Data
{
get { return data; } set { data = value; }
}
}
private Node head;
// constructor
public GenericList()
{
head = null;
}
// T as method parameter type:
public void AddHead(T t)
{
Node n = new Node(t);
n.Next = head;
head = n;
}
public IEnumerator<T> GetEnumerator()
{
Node current = head;
while (current != null)
{
yield return current.Data;
current = current.Next; } }}
|
|
class TestGenericList{
static void Main() {
// int is the type argument
GenericList<int> list = new GenericList<int>();
for (int x = 0; x < 10; x++)
{
list.AddHead(x);
}
foreach (int i in list)
{
System.Console.Write(i + " ");
}
System.Console.WriteLine("\nDone");
}
}
|
- 1. 泛型——泛型的繼承性
- 2. Java泛型---泛型的繼承
- 3. C#編程-105：泛型繼承之泛型類繼承普通類
- 4. java基礎(28)--泛型與類型擦除、泛型與繼承
- 5. 泛型繼承之開放與封閉
- 6. 多個泛型繼承調用
- 7. 泛型繼承的幾種寫法
- 8. java基礎-泛型的繼承問題
- 9. Java泛型類的繼承關係
- 10. Java繼承 | 泛型擦除和轉換
- 更多相關文章...
- • C# 繼承 - C#教程
- • Swift 繼承 - Swift 教程
- • Kotlin學習（二）基本類型
- • 委託模式
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. 泛型——泛型的繼承性
- 2. Java泛型---泛型的繼承
- 3. C#編程-105：泛型繼承之泛型類繼承普通類
- 4. java基礎(28)--泛型與類型擦除、泛型與繼承
- 5. 泛型繼承之開放與封閉
- 6. 多個泛型繼承調用
- 7. 泛型繼承的幾種寫法
- 8. java基礎-泛型的繼承問題
- 9. Java泛型類的繼承關係
- 10. Java繼承 | 泛型擦除和轉換