什麼是泛型
泛型是jdk5引入的類型機制，就是將類型參數化，它是早在1999年就制定的jsr14的實現。
泛型機制將類型轉換時的類型檢查從運行時提前到了編譯時，使用泛型編寫的代碼比雜亂的使用object並在需要時再強制類型轉換的機制具有更好的可讀性和安全性。
泛型程序設計意味着程序可以被不同類型的對象重用，類似c++的模版。
泛型對於集合類尤其有用，如ArrayList。這裏可能有疑問，既然泛型爲了適應不同的對象，ArrayList本來就可以操作不同類型的對象呀？那是因爲沒有泛型之前採用繼承機制實現的，實際上它只維護了一個Object對象的數組。結果就是對List來說它只操作了一類對象Object，而在用戶看來卻可以保存不同的對象。
泛型提供了更好的解決辦法——類型參數，如：
List<String> list = new ArrayList<String>()；這樣解決了幾個問題：
1 可讀性，從字面上就可以判斷集合中的內容類型；
2 類型檢查，避免插入非法類型。
3 獲取數據時不在需要強制類型轉換。
泛型類
public class Pair<T>{
private T field1;
}其中 <T> 是類型參數定義。
使用時：Pair<String> p = new Pair<String>();
此時類內部的field1就是字符串類型了。
如果引用多個類型，可以使用逗號分隔：<S, D>
類型參數名可以使用任意字符串，建議使用有代表意義的單個字符，以便於和普通類型名區分，如：T代表type，有原數據和目的數據就用S，D，子元素類型用E等。當然，你也可以定義爲XYZ,甚至xyZ。
泛型方法
泛型方法定義如下：
public static <T> T marshalle(T arg){}與泛型類一樣，<T> 是類型參數定義。如：
public class GenericMethod {
public static <T> T getMiddle(T... a){
return a[a.length/2];
}
}嚴格的調用方式：
String o=GenericMethod.<String>getMiddle("213","result","12");一般情況下調用時可以省略，看起來就像定義String類型參數的方法：
GenericMethod.getMiddle(String,String,String)，這是因爲jdk會根據參數類型進行推斷。看一下下面的例子：
Object o=GenericMethod.getMiddle("213",0,"12");
System.out.println(o.getClass());
System.out.println(o);輸出結果爲：
class java.lang.Integer
0這是因爲jdk推斷三個參數的共同父類，匹配爲Object,那麼相當於：
Object o=GenericMethod.<Object>getMiddle("213",0,"12");習慣了類型參數放在類的後面，如ArrayList<String>，泛型方法爲什麼不放在後面？看一個例子：
public static <T,S> T f(T t){return t;}
public static class a{}
public static class b{}
//儘量噁心一點
@Test
public void test(){
a c=new a();
<a,b>f(c);//OK
f<a,b>(c);//error,看起來像是一個逗號運算符連接的兩個邏輯表達式,當然目前java中除了for(...)並不支持逗號運算符
}因此，爲了避免歧義，jdk採用類型限定符前置。
泛型方法與泛型類的方法
如果泛型方法定義在泛型類中，而且類型參數一樣：
public class GenericMethod<T> {
public <T> void sayHi(T t){
System.out.println("Hi "+t);
}
}是不是說，定義GenericMethod時傳了 Integer 類型，sayHi()也就自動變成 Integer 了呢？No。
String i="abc";
new GenericMethod<Integer>().<String>sayHi(i);該代碼運行一點問題都沒有。原因就在於泛型方法中的<T>,如果去掉它，就有問題了。
The method sayHi(Integer) in the type GenericMethod<Integer> is not applicable for the arguments
(String)小結：
泛型方法有自己的類型參數，泛型類的成員方法使用的是當前類的類型參數。
方法中有<T> 是泛型方法；沒有的，稱爲泛型類中的成員方法。
類型參數的限定
如果限制只有特定某些類可以傳入T參數，那麼可以對T進行限定，如：只有實現了特定接口的類：<T extends Comparable>，表示的是Comparable及其子類型。
爲什麼是extends不是 implements，或者其他限定符？
嚴格來講，該表達式意味着：`T subtypeOf Comparable`,jdk不希望再引入一個新的關鍵詞;
其次，T既可以是類對象也可以是接口，如果是類對象應該是`implements`,而如果是接口，則應該是`extends`；從子類型上來講，extends更接近要表達的意思。
好吧，這是一個約定。限定符可以指定多個類型參數，分隔符是 &，不是逗號，因爲在類型參數定義中，逗號已經作爲多個類型參數的分隔符了，如:<T,S extends Comparable & Serializable>。
泛型限定的優點：
限制某些類型的子類型可以傳入，在一定程度上保證類型安全；
可以使用限定類型的方法。如：
public class Parent<T>{
private T name;
public T getName() {
return name;
}
public void setName(T name) {
//這裏只能使用name自object繼承的方法
this.name = name;
}
}加上限定符，就可以訪問限定類型的方法了，類型更明確。
public class Parent<T extends List<T>>{
private T name;
public T getName() {
return name;
}
public void setName(T name) {
//這裏可以訪問List的方法，如name.size()
this.name = name;
}
}注：
我們知道final類不可繼承，在繼承機制上class SomeString extends String是錯誤的，但泛型限定符使用時是可以的：<T extends String>，只是會給一個警告。
後面的通配符限定有一個super關鍵字，這裏沒有。
泛型擦除
泛型只在編譯階段有效，編譯後類型被擦除了，也就是說jvm中沒有泛型對象，只有普通對象。所以完全可以把代碼編譯爲jdk1.0可以運行的字節碼。
擦除的方式
定義部分，即尖括號中間的部分直接擦除。
public class GenericClass<T extends Comparable>{}擦除後：
public class GenericClass{}引用部分如：
public T field1;其中的T被替換成對應的限定類型，擦除後：
public Comparable field1;如果沒有限定類型：
public class GenericClass<T>{
public T field1;
}那麼的替換爲object,即:
public class GenericClass{
public Object field1;
}有多個限定符的，替換爲第一個限定類型名。如果引用了第二個限定符的類對象，編譯器會在必要的時候進行強制類型轉換。
public class GenericClass<T extends Comparable & Serializable>{
public T field1;
}類擦除後變爲：
public class GenericClass{
public Comparable field1;
}而表達式返回值返回時，泛型的編譯器自動插入強制類型轉換。
泛型擦除的殘留
反編譯GenericClass：
Compiled from "GenericClass.java"
public class com.pollyduan.generic.GenericClass<T> {
public T field1;
public com.pollyduan.generic.GenericClass();
}好像前面說的不對啊，這還是T啊，沒有擦除呀？
這就是擦除的殘留。反彙編：
{
public T field1;
descriptor: Ljava/lang/Object;
flags: ACC_PUBLIC
Signature: #8 // TT;
public com.pollyduan.generic.GenericClass();
descriptor: ()V
flags: ACC_PUBLIC
Code:
stack=1, locals=1, args_size=1
0: aload_0
1: invokespecial #12 // Method java/lang/Object."<init>":()V
4: return
LineNumberTable:
line 2: 0
LocalVariableTable:
Start Length Slot Name Signature
0 5 0 this Lcom/pollyduan/generic/GenericClass;
LocalVariableTypeTable:
Start Length Slot Name Signature
0 5 0 this Lcom/pollyduan/generic/GenericClass<TT;>;
}
SourceFile: "GenericClass.java"
Signature: #22 // <T:Ljava/lang/Object;>Ljava/lang/Object;其中：
descriptor：對方法參數和返回值進行描述；
signature：泛型類中獨有的標記，普通類中沒有，JDK5才加入，標記了定義時的成員簽名，包括定義時的泛型參數列表，參數類型，返回值等；
可以看到public T field1;是簽名，還保留了定義的格式；其對應的參數類型是Ljava/lang/Object;。
最後一行是類的簽名，可以看到T後面有跟了擦除後的參數類型：<T:Ljava/lang/Object;>。
這樣的機制，對於分析字節碼是有意義的。
泛型的約束和限制
不能使用8個基本類型實例化類型參數
原因在於類型擦除，Object不能存儲基本類型：
byte,char,short,int,long,float,double，boolean
從包裝類角度來看，或者說三個：
Number(byte,short,int,long,float,double),char,boolean
類型檢查不可使用泛型
if(aaa instanceof Pair<String>){}//error
Pair<String> p = (Pair<String>) a;//warn
Pair<String> p;
Pair<Integer> i;
i.getClass()==p.getClass();//true不能創建泛型對象數組
GenericMethod<User>[] o=null;//ok
o=new GenericMethod<User>[10];//error可以定義泛型類對象的數組變量，不能創建及初始化。
注，可以創建通配類型數組，然後進行強制類型轉換。不過這是類型不安全的。
o=(GenericMethod<User>[]) new GenericMethod<?>[10];不可以創建的原因是：因爲類型擦除的原因無法在爲元素賦值時類型檢查，因此jdk強制不允許。
有一個特例是方法的可變參數，雖然本質上是數組，卻可以使用泛型。
安全的方法是使用List。
Varargs警告
java不支持泛型類型的對象數組，可變參數是可以的。它也正是利用了強制類型轉換，因此同樣是類型不安全的。所以這種代碼編譯器會給一個警告。
public static <T> T getMiddle(T... a){
return a[a.length/2];
}去除警告有兩種途徑：一種是在定義可變參數方法上（本例中的getMiddle()）加上@SafeVarargs註解，另一種是在調用該方法時添加@SuppressWarnings("unchecked")註解。
不能實例化泛型對象
T t= new T();//error
T.class.newInstance();//error
T.class;//error解決辦法是傳入Class<T> t參數，調用t.newInstance()。
public void sayHi(Class<T> c){
T t=null;
try {
t=c.newInstance();
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("Hi "+t);
}不能在泛型類的靜態域中使用泛型類型
public class Singleton<T>{
private static T singleton; //error
public static T getInstance(){} //error
public static void print(T t){} //error
}但是，靜態的泛型方法可以使用泛型類型:
public static <T> T getInstance(){return null;} //ok
public static <T> void print(T t){} //ok這個原因很多資料中都沒說的太明白，說一下個人理解，僅供參考：
1. 泛型類中，<T>稱爲類型變量,實際上就相當於在類中隱形的定義了一個不可見的成員變量：`private T t;`，這是對象級別的，對於泛型類型變量來說是在對象初始化時才知道其具體類型的。而在靜態域中，不需要對象初始化就可以調用，這是矛盾的。
2. 靜態的泛型方法，是在方法層面定義的，就是說在調用方法時，T所指的具體類型已經明確了。不能捕獲泛型類型的對象
Throwable類不可以被繼承，自然也不可能被catch。
public class GenericThrowable<T> extends Throwable{
//The generic class GenericThrowable<T> may not subclass java.lang.Throwable
}但由於Throwable可以用在泛型類型參數中，因此可以變相的捕獲泛型的Throwable對象。
@Test
public void testGenericThrowable(){
GenericThrowable<RuntimeException> obj=new GenericThrowable<RuntimeException>();
obj.doWork(new RuntimeException("why?"));
}
public static class GenericThrowable<T extends Throwable>{
public void doWork(T t) throws T{
try{
int i=3/0;
}catch(Throwable cause){
t.initCause(cause);
throw t;
}
}
}這個能幹什麼？
@Test
public void testGenericThrowable(){
GenericThrowable<RuntimeException> obj=new GenericThrowable<RuntimeException>();
obj.doWork(new RuntimeException("What did you do?"));
}
public static class GenericThrowable<T extends Throwable>{
public void doWork(T t) throws T{
try{
Reader reader=new FileReader("notfound.txt");
//這裏應該是checked異常
}catch(Throwable cause){
t.initCause(cause);
throw t;
}
}
}FileReader實例化可能拋出已檢查異常，jdk中要求必須捕獲或者拋出已檢查異常。這種模式把它給隱藏了。也就是說可以消除已檢查異常，有點不地道，顛覆了java異常處理的認知，後果不可預料，慎用。
擦除的衝突
重載與重寫
定義一個普通的父類：
package com.pollyduan.generic;
public class Parent{
public void setName(Object name) {
System.out.println("Parent:" + name);
}
}那麼繼承一個子類，Son.java
package com.pollyduan.generic;
public class Son extends Parent {
public void setName(String name) {
System.out.println("son:" + name);
}
public static void main(String[] args) {
Son son=new Son();
son.setName("abc");
son.setName(new Object());
}
}Son類重載了一個setName(String)方法，這沒問題。輸出：
son:abc
Parent:java.lang.Object@6d06d69cParent修改泛型類：
package com.pollyduan.generic;
public class Parent<T>{
public void setName(T name) {
System.out.println("Parent:" + name);
}
}從擦除的機制得知，擦除後的class文件爲：
package com.pollyduan.generic;
public class Parent{
public void setName(Object name) {
System.out.println("Parent:" + name);
}
}這和最初的非泛型類是一樣的，那麼Son類修改爲：
package com.pollyduan.generic;
public class Son extends Parent<String> {
public void setName(String name) {
System.out.println("son:" + name);
}
public static void main(String[] args) {
Son son=new Son();
son.setName("abc");
son.setName(new Object());//The method setName(String) in the type Son is not applicable for the arguments (Object)
}
}發現重載無效了。這是泛型擦除造成的，無論是否在setName(String)是否標註爲@Override都將是重寫，都不是重載。而且，即便你不寫setName(String)方法，編譯器已經默認重寫了這個方法。
換一個角度來考慮，定義Son時，Parent已經明確了類型參數爲String，那麼再寫setName(Stirng)是重寫，也是合理的。
package com.pollyduan.generic;
public class Son extends Parent<String> {
public static void main(String[] args) {
Son son=new Son();
son.setName("abc");//ok
}
}反編譯會發現，編譯器在內部編譯了兩個方法：
public void setName(java.lang.String);
public void setName(java.lang.Object);setName(java.lang.Object) 雖然是public但編碼時會發現不可見，它稱爲”橋方法”，它會重寫父類的方法。
Son son=new Son();
Parent p=son;
p.setName(new Object());強行調用會轉換異常，也就證明了它實際上調用的是son的setName(String)。
我非要重載怎麼辦？只能曲線救國，改個名字吧。
public void setName2(String name) {
System.out.println("son:" + name);
}繼承泛型的參數化
一個泛型類的類型參數不同，稱之爲泛型的不同參數化。
泛型有一個原則：一個類或類型變量不可成爲兩個不同參數化的接口類型的子類型。如：
package com.pollyduan.generic;
import java.util.Comparator;
public class Parent implements Comparator{
@Override
public int compare(Object o1, Object o2) {
return 0;
}
}
public class Son extends Parent implements Comparator {
}這樣是沒有問題的。如果增加了泛型參數化：
package com.pollyduan.generic;
import java.util.Comparator;
public class Parent implements Comparator<Parent>{
@Override
public int compare(Parent o1, Parent o2) {
return 0;
}
}
package com.pollyduan.generic;
import java.util.ArrayList;
import java.util.Comparator;
public class Son extends Parent implements Comparator<Son> {
//The interface Comparator cannot be implemented more than once with different arguments
}原因是Son實現了兩次Comparator，擦除後均爲Comparator，造成了衝突。
通配符類型
通配符是在泛型類使用時的一種機制，不能用在泛型定義時的泛型表達式中(這是泛型類型參數限定符)。
子類型通配符
如果P是S的超類，那麼 Pair<S>就是Pair<? extends P>的子類型，通配符就是爲了解決這個問題的。
這稱爲子類型限定通配符，又稱上邊界通配符(upper bound wildcard Generics)，代表繼承它的所有子類型，通配符匹配的類型不允許作爲參數傳入，只能作爲返回值。
public static void test1() {
Parent<Integer> bean1 = new Parent<Integer>();
bean1.setName(123);
Parent<? extends Number> bean2 = bean1;
Integer i = 100;
bean2.setName(i);// 編譯錯誤
Number s = bean2.getName();
System.out.println(s);
}getName()的合理性：
無論bean2指向的是任何類型的對象，只要是Number的子類型，都可以用Number類型變量接收。爲什麼setName(str)會拋出異常呢？
1. <? extends Number> 表明了入參是Number的子類型；
2. 那麼bean2 可以指向Parent<Integer>，也可以指向Parent<Double>，這都是符合規則的;
3. 再看setName(<? extends Number>)，邏輯上傳入Integer或者Double對象都是符合邏輯的；
4. 如果bean2指向的是Parent<Integer>，而傳入的對象是Double的，兩個看似合理的規則到一起就不行了。
5. 因此，jdk無法保證類型的安全性，乾脆不允許這樣——不允許泛型的子類型通配類型作爲入參。超類型通配符
與之對應的是超類型 Pair
public static void test2() { public static void test2() {
Parent<Number> bean1 = new Parent<Number>();
bean1.setName(123);
Parent<? super Integer> bean2 = bean1;
Integer i = 100;
bean2.setName(i);
Integer s = bean2.getName();// 編譯錯誤
Object o = bean2.getName();// ok
System.out.println(o);
}
}setName的可行性：
1. 無論bean2指向Parent<Number>，Parent<Integer>還是Parent<Object>都是允許的；
2. 都可以傳入Integer或Integer的子類型。getName爲毛報錯？
1. 由於限定類型的超類可能有很多，getName返回類型不可預知，如Integer 或其父類型Number/OtherParentClass...都無法保證類型檢查的安全。
2. 但是由於Java的所有對象的頂級祖先類都是Object，因此可以用Object獲取getName返回值。無限定通配符
Pair<?> 就是 Pair<? extends Object>
因此，無限定通配符可以作爲返回值，不可做入參。
返回值只能保存在Object中。
P<?> 和P
Pair可以調用setter方法，這是它和Pair<?>最重要的區別。
P<?> 不等於 P<Object>
P<Object>是P<?>的子類。
類型通配符小結
1. 限定通配符總是包括自己；
2. 子類型通配符：set方法受限，只可讀，不可寫；
3. 超類型通配符：get方法受限，不可讀(Object除外)，只可寫；
4. 無限定通配符，只可讀不可寫；
5. 如果你既想存，又想取，那就別用通配符；
6. 不可同時聲明子類型和超類型限定符，即extends和super只能出現一個。通配符的受限只針對setter(T)和T getter(),如果定義了一個setter(Integer)這種具體類型參數的方法，無限制。如：如果增加一個方法setId(Integer id)，可以任意調用。
通配符捕獲
通配符限定類中可以使用T，編譯器適配類型。
有一個鍵值對的泛型類：
@Data
class Pair<T> {
private T key;
private T value;
}使用通配類型創建一個swap方法交換key-value，交換時需要先使用一個臨時變量保存一個字段：
public static void swap(Pair<?> p){
// ? k=p.getKey();//error，?不可作爲具體類型限定符
Object k=p.getKey();//好吧，換成object，ok
p.setKey(p.getValue());//but,通配符類型不可做入參
p.setValue(k);
}這裏有一個辦法解決它，再封裝一個swapHelper():
private static <T> void swapHelper(Pair<T> p){
T k=p.getKey();
p.setKey(p.getValue());
p.setValue(k);
}
public static void swap(Pair<?> p){
swapHelper(p);
}這種方式，稱爲：通配符捕獲，用一個Pair<T> 來捕獲 Pair<?>中的類型。
注：
當然，你完全可以直接使用swapHelper，這裏只是爲了說明這樣一種捕獲機制。
只允許捕獲單個、確定的類型，如：ArrayList<Pair<?>> 是無法使用 ArrayList<Pair<T>> 捕獲的。泛型與繼承
繼承的原則
繼承泛型類時，必須對父類中的類型參數進行初始化。或者說父類中的泛型參數必須在子類中可以確定具體類型。
例如：有一個泛型類Parent<T>，那麼Son類定義時有兩種方式初始化父類型的類型參數：
1 用具體類型初始化：
public class Son extends Parent<String>{}2 用子類中的泛型類型初始化父類：
public class Son<T> extends Parent<T>{}Pair<P>和Pair<S>
無論P和S有什麼繼承關係，一般Pair<P>和Pair<S>沒什麼關係。
Pair<Son> s=new Pair<>();
Pair<Parent> p=s;//errorParent<T>和Son<T>
泛型類自身可以繼承其他類或實現接口，如 List實現ArrayList
泛型類可以擴展泛型類或接口，如ArrayList 實現了 List，此時ArrayList可以轉換爲List。這是安全的。
Parent<T>和Parent
Parent<T>隨時都可以轉換爲原生類型Parent，但需要注意類型檢查的安全性。
package com.pollyduan.generic;
import java.io.File;
class Parent<T> {
private T name;
public T getName() {
return name;
}
public void setName(T name) {
this.name = name;
}
public static void main(String[] args) {
Parent<String> p1=new Parent<>();
p1.setName("tom");
System.out.println(p1.getName());
Parent p2=p1;
p2.setName(new File("1.txt"));
System.out.println(p2.getName());
}
} 運行沒有異常，注意。
Person<? extends XXX>
嚴格講通配符限定的泛型對象不屬於繼承範疇，但使用中有類似繼承的行爲。
Son是Parent的子類型，那麼Person<? extends Son>就是Person<? extends Parent> 的子類型。
Person<? extends Object> 等同於 Person<?>,那麼基於上以規則可以推斷：Person<? extends Parent> 是 Person<?> 的子類型。
Person<Object> 是 Person<?> 的子類型。
泛型與反射
泛型相關的反射
有了泛型機制，jdk的reflect包中增加了幾個泛型有關的類：
Class<T>.getGenericSuperclass()
獲取泛型超類
ParameterizedType
類型參數實體類實例
User.java
package com.pollyduan.generic;
@Data
public class User {
private Integer id;
private String name;
}AbstractBaseDaoImpl.java
package com.pollyduan.generic;
public abstract class AbstractBaseDaoImpl<T> {
public AbstractBaseDaoImpl() {
Type t = getClass().getGenericSuperclass();
System.out.println(t);
}
}UserDaoImpl.java
package com.pollyduan.generic;
public class UserDaoImpl extends AbstractBaseDaoImpl<User> {
public static void main(String[] args) {
UserDaoImpl userDao=new UserDaoImpl();
}
}運行UserDaoImpl.main(),輸出：
com.pollyduan.generic.AbstractBaseDaoImpl<com.pollyduan.generic.User>可以看到，在抽象類AbstractBaseDaoImpl中可以拿到泛型類的具體類。
從這一機制，可以通過AbstractBaseDaoImpl實現通用的JDBA DAO。
完善AbstractBaseDaoImpl.java
package com.pollyduan.generic;
import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.stream.Collectors;
public abstract class AbstractBaseDaoImpl<T, K> {
private Class<T> entityClass;
private Class<T> primaryKeyClass;
public AbstractBaseDaoImpl() {
Type t = getClass().getGenericSuperclass();
ParameterizedType pt = (ParameterizedType) t;
Type[] typeParameters = pt.getActualTypeArguments();
entityClass = (Class<T>) typeParameters[0];
primaryKeyClass = (Class<T>) typeParameters[1];
}
public void save(T t) {
StringBuilder sb = new StringBuilder("INSERT INTO ");
sb.append(entityClass.getSimpleName());
sb.append("(");
Field[] fields = entityClass.getDeclaredFields();
String fieldNames = Arrays.asList(fields).stream().map(x -> x.getName()).collect(Collectors.joining(","));
sb.append(fieldNames);
sb.append(") VALUES(");
sb.append(fieldNames.replaceAll("[^,]+", "?"));
sb.append(")");
System.out.println(sb.toString());
//根據反射還要遍歷fields處理變量綁定，略。
}
public void delete(K k) {
StringBuilder sb = new StringBuilder("DELETE FROM ");
sb.append(entityClass.getSimpleName());
sb.append(" WHERE ID=?");// 這裏默認主鍵名爲id，應該配合註解動態獲取主鍵名
System.out.println(sb.toString());
}
public void update(T t) {
StringBuilder sb = new StringBuilder("UPDATE ");
sb.append(entityClass.getSimpleName());
sb.append(" SET ");
Field[] fields = entityClass.getDeclaredFields();
for (int i = 0; i < fields.length; i++) {
if (fields[i].getName().toLowerCase().equals("id")) {
continue;
}
sb.append(fields[i].getName());
sb.append("=?");
if (i < fields.length - 1) {
sb.append(",");
}
}
sb.append(" WHERE ID=?");
System.out.println(sb.toString());
}
public T get() throws Exception {
T t = null;
// 模擬resultset
Map<String, Object> rs = new HashMap<>();
t = entityClass.newInstance();
Field[] fields = entityClass.getDeclaredFields();
for (Field field : fields) {
field.setAccessible(true);
field.set(t, rs.get(field.getName()));
}
return t;
}
public static void main(String[] args) {
UserDaoImpl userDao=new UserDaoImpl();
User user1=new User();
userDao.save(user1);
userDao.delete(1);
userDao.update(user1);
try {
User user2=userDao.get();
System.out.println(user2);
} catch (Exception e) {
e.printStackTrace();
}
}
}
有現成的ORM框架可用，這裏就意思意思得了。輸出：
INSERT INTO User(id,name) VALUES(?,?)
DELETE FROM User WHERE ID=?
UPDATE User SET name=? WHERE ID=?
User(id=1, name=Peter)有問題可加Q羣討論：9040323
