对于jdbc的总结，我想等我忘记一段时间再来总结，就像现在我对JavaSE部分的总结和回顾，我感觉这样有个好处，你会对这个知识有更加深刻的理解，比如我学jdbc的时候在泛型的使用上有很多迷惑的地方，现在返回来看，记忆和理解更加深刻了。
泛型（Generics）：
泛型的出现：since JDK1.5
IBM的DW中给的解释我认为很好：
Generics是程序设计语言的一种技术，指将程序中数据类型进行参数化，它本质上是对程序的数据类型进行一次抽象，扩展语言的表达能力，同时支持更大力度的代码复用。
思维扩散一下：
Java总抽象类，接口是不是就是这样的思想，将类进行抽象化，扩展了语言的表达能力，更大力度的支持了代码复用。
总结：
Generics——>对数据类型（引用类型）进行抽象
abstract Class/interface——>对类进行抽象
共性：抽象。
优点：提高了代码的复用性。
ps:这就总结了一下。。。。！
为什么要使用泛型？
我们要向一个List中添加一些学生的学号：
List list = new ArrayList();
list.add(100);
list.add(101);
list.add(102);
//但是我比较调皮，就想把我名字给加进去
list.add("雷锋");
//我们来遍历，看看同学们的学号
for(Object object : list){
int sId = (Integer)object;//强制类型转换和自动拆箱
System.out.println(sId);
}发现在编译的时候报错了，是因为雷锋这位同学比较调皮，ClassCastException
为了解决这种对数据的破坏和强制类型转换可能报异常的问题，所以我们就有了泛型。
看看使用泛型后：
List<Integer> list = new ArrayList<>();//since JDK1.7
list.add(100);
list.add(101);
list.add(102);
//但是我比较调皮，就想把我名字给加进去
list.add("雷锋");
//我们来遍历，看看同学们的学号
for(Integer sid : list){
System.out.println(sId);
}发现雷锋这位调皮的同学添加不进去了，编译报错了。
泛型的使用：
1.集合中使用泛型
2.自定义泛型类，泛型接口，泛型方法
3.泛型与继承的关系
4.通配符
集合中使用泛型：
具体的就不多说了，在使用的时候，相信大家都深有体会。特别是像我一样，见不得一点点的警告，总要思考为什么要出现这样的警告。结果我的所有代码都没有一点警告。
自定义泛型类：
可以参考集合中泛型类的使用，不知道的可以参考API中集合部分。
public class Order<T>{
private int id;
private String name;
private T t;
List<T> list = new ArrayList<T>();
public void add(T t){
list.add();
}
public void setT(T t){
this.t = t;
}
public T getT(){
return t;
}
public void setId(int id){
this.id = id;
}
public void getId(){
return id;
}
.
.
.
//name 属性的get和set方法一样，不写了。
}
自定义接口与之类似，不再赘述。
泛型方法：
还是上面的例子，加入一个泛型方法：
public class Order<T>{
private int id;
private String name;
private T t;
List<T> list = new ArrayList<T>();
public void add(T t){
list.add();
}
public void setT(T t){
this.t = t;
}
public T getT(){
return t;
}
public void setId(int id){
this.id = id;
}
public void getId(){
return id;
}
.
.
.
//name 属性的get和set方法一样，不写了。
//泛型方法
public <E> E getE(E e){
return e;
}
}
注意看泛型方法的声明。和泛型类，泛型接口有所不同。
泛型和类的继承关系：
Object obj = null;
String str = "hellowrold";
obj = str;这样的方式，我们知道可以通过编译，可以运行，多态的使用（向上转型），在看下面：
List<Object> list = null;
List<String> list2 = new ArrayList<>();
list2.add("zhangsan");
list2.add("lisi");
list = list2;这里编译会报错 mismatch，类型不匹配。
—–>若类A是类B的子类，那么List<A> 就不是List<B> 的子接口
—–>list2和list不具备继承关系
—–>带泛型的类不具备继承关系，他们是同级关系
—–？哪我要向Object添加别的类型的该怎么办？
List<T extends Object>
可以理解为一种小于等于的关系
而还有一种使用方式（不是针对上面的问题）：
List<T super Number>
可以理解为一种大于等于的关系
引用上面的一句话：
带泛型的类不具备继承关系，他们是同级关系
——>那有没有一个类是所有泛型类的父类呢？
通配符：?
List<A>,List<B> 是 List<?>的子类
? extends A :可以存放A及其子类或子接口
? super B :可以存放B及其父类或父接口
注意一点：使用通配符的类，只能写，而不能读（null除外）
总结一下，使用中需要理解和注意的地方：
1.上面所说的参数化，其实就是泛型的意思。
2.对象实例化时，不指定泛型，默认为Object
3.泛型的引用之间不能相互赋值
4.加入集合中的泛型元素必须和指定的泛型类型一致
5.静态方法中不能使用泛型
理解：静态方法的先于对象而存在，可以直接通过类名来调用，调用的时候还没有明确泛型的类型是什么，所以不能使用泛型。
6.不能再cathch中使用泛型，编译报错
7.从泛型类派生子类，子类需具体化
泛型核心思想：
将类或接口中的数据限制为一个特定的数据类型
最后来一个泛型的使用的例子：
用户在设计类的时候往往会使用类的关联关系，例如，一个人中可以定义一个信息的属性，但是一个人可能有各种各样的信息（如联系方式、基本信息等），所以此信息属性的类型就可以通过泛型进行声明，然后只要设计相应的信息类即可。
interface Info{
}public class Contact implements Info{
private String address;
private Stirng phone;
private String zipCode;
//无参构造器
//有参构造器
//get and set method
//toString()方法
}public class Inroduction implements Info{
private String name;
private String sex;
private int age;
//同上
}class Person<T extends Info>{
private T info;
public Person(T info){
this.info = info;
}
//get and set method
//toString()
}public class GenericPerson{
public static void main(String[] args){
Person<Contact> per = new Person<>(new Contact("Beijign", "88888888888", "000000"));
}
System.out.println(per);
Person<Introduction> per2 = new Person<>(new Introduction("Jay", "M", 23))
System.out.println(per2);
}