泛型知識：
一般我們并不需要太多了解泛型，因為Freebasic主要是和c一樣，通過宏來實現(xiàn)和泛型類似的功能。一般泛型主要是應(yīng)用在集合類中。但在這里還是有必要適度了解一下泛型的概念，以便于以后在進行類的封裝時，適度使用泛型會帶來更多的方面。
（注：vba中沒有泛型的概念，因為VBA中有一個萬能而讓人痛苦不堪的Variant類型)
************************************************************
以下內(nèi)容是java的泛型基礎(chǔ)
************************************************************
       1、什么是泛型？泛型是指在定義類或者接口的時候可以為類和接口指定類型形參，在定義變量、定義方法是該類型形參可以當(dāng)做普通的類型來使用，并且該類型形參在定義變量和創(chuàng)建對象的確定。它的本質(zhì)是參數(shù)化類型，也就是說所操作的數(shù)據(jù)類型被指定為一個參數(shù)。這種參數(shù)類型可以用在類、接口和方法的創(chuàng)建中，分別稱為泛型類、泛型接口、泛型方法。 Java語言引入泛型的好處是安全簡單。
在引入泛型之前，Java類型分為原始類型、復(fù)雜類型，其中復(fù)雜類型分為數(shù)組和類。引入泛型后，一個復(fù)雜類型就可以在細分成更多的類型。
例如原先的類型List，現(xiàn)在在細分成List<Object>, List<String>等更多的類型。
注意，現(xiàn)在List<Object>, List<String>是兩種不同的類型，
他們之間沒有繼承關(guān)系，即使String繼承了Object。下面的代碼是非法的
    List<String> ls = new ArrayList<String>();
    List<Object> lo = ls;
這樣設(shè)計的原因在于，根據(jù)lo的聲明，編譯器允許你向lo中添加任意對象（例如Integer），但是此對象是
List<String>，破壞了數(shù)據(jù)類型的完整性。
在引入泛型之前，要在類中的方法支持多個數(shù)據(jù)類型，就需要對方法進行重載，在引入泛型后，可以解決此問題
（多態(tài)），更進一步可以定義多個參數(shù)以及返回值之間的關(guān)系。
例如
public void write(Integer i, Integer[] ia);
public void write(Double  d, Double[] da);
的泛型版本為
public <T> void write(T t, T[] ta);

2. 定義&使用
 類型參數(shù)的命名風(fēng)格為：
 推薦你用簡練的名字作為形式類型參數(shù)的名字(如果可能，單個字符)。最好避免小寫字母，這使它和其他的普通
 的形式參數(shù)很容易被區(qū)分開來。
 使用T代表類型，無論何時都沒有比這更具體的類型來區(qū)分它。這經(jīng)常見于泛型方法。如果有多個類型參數(shù)，我們
 可能使用字母表中T的臨近的字母，比如S。
 如果一個泛型函數(shù)在一個泛型類里面出現(xiàn)，最好避免在方法的類型參數(shù)和類的類型參數(shù)中使用同樣的名字來避免混
 淆。對內(nèi)部類也是同樣。
 
 2.1 定義帶類型參數(shù)的類
 在定義帶類型參數(shù)的類時，在緊跟類命之后的<>內(nèi),指定一個或多個類型參數(shù)的名字，同時也可以對類型參數(shù)的取
 值泛圍進行限定，多個類型參數(shù)之間用,號分隔。
 定義完類型參數(shù)后，可以在定義位置之后的類的幾乎任意地方（靜態(tài)塊，靜態(tài)屬性，靜態(tài)方法除外）使用類型參數(shù)，
 就像使用普通的類型一樣。
 注意，父類定義的類型參數(shù)不能被子類繼承。
 public class TestClassDefine<T, S extends T> {
     ....  
 }
 
 2.2 定義待類型參數(shù)方法
 在定義帶類型參數(shù)的方法時，在緊跟可見泛圍修飾（例如public）之后的<>內(nèi),指定一個或多個類型參數(shù)的名字，
 同時也可以對類型參數(shù)的取值泛圍進行限定，多個類型參數(shù)之間用,號分隔。
 定義完類型參數(shù)后，可以在定義位置之后的方法的任意地方使用類型參數(shù)，就像使用普通的類型一樣。
 例如：
 public <T, S extends T> T testGenericMethodDefine(T t, S s){
     ...
 }
 注意：定義帶類型參數(shù)的方法，騎主要目的是為了表達多個參數(shù)以及返回值之間的關(guān)系。例如本例子中T和S的繼
 承關(guān)系， 返回值的類型和第一個類型參數(shù)的值相同。
 如果僅僅是想實現(xiàn)多態(tài)，請優(yōu)先使用通配符解決。通配符的內(nèi)容見下面章節(jié)。
 public <T> void testGenericMethodDefine2(List<T> s){
     ...
 }
 應(yīng)改為
 public void testGenericMethodDefine2(List<？> s){
     ...
 }
 
3. 類型參數(shù)賦值
 當(dāng)對類或方法的類型參數(shù)進行賦值時，要求對所有的類型參數(shù)進行賦值。否則，將得到一個編譯錯誤。
 
 3.1 對帶類型參數(shù)的類進行類型參數(shù)賦值
 對帶類型參數(shù)的類進行類型參數(shù)賦值有兩種方式
 第一聲明類變量或者實例化時。例如
 List<String> list;
 list = new ArrayList<String>;
 第二繼承類或者實現(xiàn)接口時。例如
 public class MyList<E> extends ArrayList<E> implements List<E> {...}
 
 3.2 對帶類型參數(shù)方法進行賦值
 當(dāng)調(diào)用泛型方法時，編譯器自動對類型參數(shù)進行賦值，當(dāng)不能成功賦值時報編譯錯誤。例如
 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 通配符
 在上面兩小節(jié)中，對是類型參數(shù)賦予具體的值，除此，還可以對類型參數(shù)賦予不確定值。例如
 List<?> unknownList;
 List<? extends Number> unknownNumberList;
 List<? super Integer> unknownBaseLineIntgerList;
 注意： 在Java集合框架中，對于參數(shù)值是未知類型的容器類，只能讀取其中元素，不能像其中添加元素，
 因為，其類型是未知，所以編譯器無法識別添加元素的類型和容器的類型是否兼容，唯一的例外是NULL

 List<String> listString;
 List<?> unknownList2 = listString;
 unknownList = unknownList2;
 listString = unknownList;//編譯錯誤
 
4. 數(shù)組泛型
 可以使用帶泛型參數(shù)值的類聲明數(shù)組，卻不可有創(chuàng)建數(shù)組
 List<Integer>[] iListArray;
 new ArrayList<Integer>[10];//編譯時錯誤
 
5. 實現(xiàn)原理

5.1. Java泛型時編譯時技術(shù)，在運行時不包含泛型信息，僅僅Class的實例中包含了類型參數(shù)的定義信息。
泛型是通過java編譯器的稱為擦除(erasure)的前端處理來實現(xiàn)的。你可以（基本上就是）把它認為是一個從源
碼到源碼的轉(zhuǎn)換，它把泛型版本轉(zhuǎn)換成非泛型版本。
基本上，擦除去掉了所有的泛型類型信息。所有在尖括號之間的類型信息都被扔掉了，因此，比如說一個
List<String>類型被轉(zhuǎn)換為List。所有對類型變量的引用被替換成類型變量的上限(通常是Object)。而且，
無論何時結(jié)果代碼類型不正確，會插入一個到合適類型的轉(zhuǎn)換。
       <T> T badCast(T t, Object o) {
         return (T) o; // unchecked warning
       }
類型參數(shù)在運行時并不存在。這意味著它們不會添加任何的時間或者空間上的負擔(dān)，這很好。不幸的是，這也意味
著你不能依靠他們進行類型轉(zhuǎn)換。

5.2.一個泛型類被其所有調(diào)用共享
下面的代碼打印的結(jié)果是什么？
       List<String> l1 = new ArrayList<String>();
       List<Integer> l2 = new ArrayList<Integer>();
       System.out.println(l1.getClass() == l2.getClass());
或許你會說false，但是你想錯了。它打印出true。因為一個泛型類的所有實例在運行時具有相同的運行時類(class)，
而不管他們的實際類型參數(shù)。
事實上，泛型之所以叫泛型，就是因為它對所有其可能的類型參數(shù)，有同樣的行為；同樣的類可以被當(dāng)作許多不同
的類型。作為一個結(jié)果，類的靜態(tài)變量和方法也在所有的實例間共享。這就是為什么在靜態(tài)方法或靜態(tài)初始化代碼
中或者在靜態(tài)變量的聲明和初始化時使用類型參數(shù)（類型參數(shù)是屬于具體實例的）是不合法的原因。

5.3. 轉(zhuǎn)型和instanceof
泛型類被所有其實例(instances)共享的，另一個暗示是檢查一個實例是不是一個特定類型的泛型類是沒有意義的。
       Collection cs = new ArrayList<String>();
       if (cs instanceof Collection<String>) { ...} // 非法
類似的，如下的類型轉(zhuǎn)換
Collection<String> cstr = (Collection<String>) cs;
得到一個unchecked warning，因為運行時環(huán)境不會為你作這樣的檢查。

6. Class的泛型處理
Java 5之后，Class變成泛型化了。
JDK1.5中一個變化是類 java.lang.Class是泛型化的。這是把泛型擴展到容器類之外的一個很有意思的例子。
現(xiàn)在，Class有一個類型參數(shù)T, 你很可能會問，T 代表什么？它代表Class對象代表的類型。比如說，
String.class類型代表 Class<String>，Serializable.class代表 Class<Serializable>。
這可以被用來提高你的反射代碼的類型安全。
特別的，因為 Class的 newInstance() 方法現(xiàn)在返回一個T, 你可以在使用反射創(chuàng)建對象時得到更精確的類型。
比如說，假定你要寫一個工具方法來進行一個數(shù)據(jù)庫查詢，給定一個SQL語句，并返回一個數(shù)據(jù)庫中符合查詢條件
的對象集合(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;
}
你可以這樣調(diào)用：
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();}
}
然后調(diào)用：
select(getMyEmpInfoFactory(), "selection string");
這個解決方案的缺點是它需要下面的二者之一：
調(diào)用處那冗長的匿名工廠類，或為每個要使用的類型聲明一個工廠類并傳遞其對象給調(diào)用的地方
這很不自然。
使用class類型參數(shù)值是非常自然的，它可以被反射使用。沒有泛型的代碼可能是：
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;
}
但是這不能給我們返回一個我們要的精確類型的集合�，F(xiàn)在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;
}
來通過一種類型安全的方式得到我們要的集合。
這項技術(shù)是一個非常有用的技巧，它已成為一個在處理注釋(annotations)的新API中被廣泛使用的習(xí)慣用法。
****************************************************************
以上內(nèi)容是java的泛型基礎(chǔ)
***************************************************************
如果依然對泛型的概念不是很了解的話，可參看c#的泛型概念