一、泛型
1.泛型类
具有一个或多个泛型变量的类被称之为泛型类。
public class A<T> {
private T t;
public A(T t) {
this.t = t;
}
public T get() {
return t;
}
}
2.泛型方法
泛型方法的特点：
方法的参数中会使用泛型变量；
方法的返回值中会使用泛型变量。
public <T> T get(T[] ts) {
return ts[ts.lengt / 2];
}
3.继承（实现）泛型类（接口）
继承泛型类需要为父类的泛型变量赋值！就好比创建泛型类的对象时需要给泛型变量赋值一样。
* 子类不是泛型类：需要给父类传递类型常量
> 当给父类传递的类型常量为String时，那么在父类中所有T都会被String替换！
* 子类是泛型类：可以给父类传递类型常量，也可以传递类型变量
// 继承泛型类1：子类也是泛型类
public class MyList<T> extends ArrayList<T> {
}
// 继承泛型类2：子类也是泛型类
public class MyList2<T> extends ArrayList<T> {
}
// 继承泛型类3：子类不是泛型类
public class MyList3 extends ArrayList<String> {
}
4.通配符
（1）通配符概述
public static void fun(List<?> list) {…}
上面代码中的“?”就是一个通配符，它只能在“<>”中使用。造成不能把它从“<>”中拿出来。
这时你可以向fun()方法传递List<String>、List<Integer>类型的参数了。当传递List<String>类型的参数时，表示给“?”赋值为String；当传递List<Integer>类型的参数给fun()方法时，表示给“?”赋值为Integer。
（2）通配符的缺点
带有通配符的参数不能使用与泛型相关的方法，例如：list.add(“hello”)编译不通过。
在上面例子中，List<?> list参数中的通配符可以被赋任何值，但同时你也不知道通配符被赋了什么值。
当你不知道“?”是什么时，会使你不能使用任何与泛型相关的方法。也就是说fun()方法的参数list不能再使用它的与泛型相关的方法了。例如：list.add(“hello”)是错误的，因为List类的add()方法的参数是T类型，而现在你不知道T是什么类型，你怎么去添加String的东西给list呢？如果使用者在调用fun()方法时传递的不是List<String>，而是List<Integer>时，你添加String当然是不可以的。
当然，还可以调用list的get()方法。就算你不知道“?”是什么类型，但它肯定是Object类型的。所以你可以：Object o = list.get(0);
（3）通配符的限制
通配符只能出现在引用的定义中，而不能出现在创建对象中。例如：new ArrayList<?>()，这是不可以的。ArrayList<?> list = null，这是可以的。
（4）带有下边界的通配符
List<? extends Number> list;
其中<? extends Number>表示通配符的下边界，即“?”只能被赋值为Number或其子类型。
当fun()方法的参数为List<? extends Number>后，说明你只能赋值给“?”Number或Number的子类型。
虽然这多了一个限制，但也有好处，因为你可以list的get()方法了。就算你不知道“?”是什么类型，但你知道它一定是Number或Number的子类型。所以：Number num = list.get(0)是可以的。
但是，还是不能调用list.add()方法！
（5）带有下边界的通配符
List<? super Integer> list;
其中<? super Integer>表示通配符的下边界，即“?”只能被赋值为Integer或其父类型。
这时再去调用list.get()方法还是只能使用Object类型来接收：Object o = list.get(0)。因为你不知道“?”到底是Integer的哪个父类。
但是你可以调用list.add()方法了，例如：list.add(new Integer(100))是正确的。因为无论“?”是Integer、Number、Object，list.add(new Integer(100))都是正确的。
（6）通配符小结
1. 方法参数带有通配符会更加通用；
2. 带有通配符类型的对象，被限制了与泛型相关方法的使用；
3. 下边界通配符：可以使用返回值为泛型变量的方法；
4. 上边界通配符：可以使用参数为泛型变量的方法。
5.泛型父类获取子类传递的类型参数
public class A<T> {
}
public class B extends A<String> {
}
public class C extends A<Integer> {
}
如果你需要在A类中得到子类给T赋值的类型，那么可以使用下面的方法：
public class A<T> {
public A() {
ParameterizedType pType = (ParameterizedType) this.getClass()
.getGenericSuperclass();
Class clazz = (Class) pType.getActualTypeArguments()[0];
System.out.println(clazz.getName());
}
}
二、注解
1.注解的概述
注释是用来替代配置文件的！我们以前总是要写一些配置文件，例如web.xml你还记得么？里面要写<servlet>和<servlet-mapping>！谁来读配置文件呢？当然是Tomcat！谁来写配置文件呢？当然是我们来写了！
在Servlet3.0中就可以使用使用注解来代替配置文件，开发者就不用再写配置文件了，而是写注解，然后Tomcat来读取注解。
注解也是类，需要定义了才能使用！
在Servlet3.0中有一个注解类为 @WebServlet，然后我们就可以在Servlet中使用@WebServlet中使用这个注解了。这个注解就是用来替代<servlet>了。然后Tomcat会通过反射来读取注解中的信息！2.java中的注解
@Override：作用在方法上的注解。当方法不是重写父类的方法时会报错；
@Deprecated：作用在方法上。标记该方法为作废方法（已过时）；
@SuppressWarnings：作用在方法上，压制警告。
3.定义注解类
定义注解类不能使用class、enum，也不能使用interface，而是使用@interface。
@interface myAnn1{}
4.使用注解
注解可以作用在：类（接口或枚举）、属性、方法、构造器、包、参数、局部变量
@MyAnn
public class Demo1 {
@MyAnn
private int a;
@MyAnn
public Demo1() {}
@MyAnn
public void fun1() {}
@MyAnn
public void fun2(@MyAnn String s) {
@MyAnn
int n = 10;
}
}
@interface MyAnn{}
5.注解的属性
定义注解时也可以给出属性
//定义了两个属性 value和value1
@interface MyAnn1{
String value();
int value1();
}
当为注解指定属性后，那么在使用注解时就必须要给属性赋值了：
@MyAnn(value1=100,value="hello")
注解的属性还可以有默认值，使用default关键字。在使用注解时就可以不给带有默认值的属性赋值了。但没有给出默认值的属性还是要赋值的。在使用注解时需要给属性赋值。
@interface MyAnn3 {
String value1() default "hello world";
String value();
}
赋值的时候可以不给有默认值的的value1属性赋值。当只给名为value的属性赋值时，还可以不给出属性的名称直接给值。
@MyAnn3("hello")
注意事项：
（1）注解的属性后面要有一对圆括号，而且圆括号内不能给出东西。就像是无参的方法一样；
（2）注解的属性类型只能是：基本类型、String、Enum、Class、注解类型、以上类型的一维数组类型；
（3）注解的属性可以有默认值，例如：int a() default 100;
（4）数组的属性默认值：int[] arr() default {1,2,3}，这里不能使用new int[]{1,2,3}
（5）使用注解时，在给数组属性赋值时的格式：@MyAnn(arr={1,2,3})；
6.注解的作用目标
在定义注解时可以限制注解的作用目录！例如让注解只能作用在类和方法上。
在定义注解时，可以使用@Target注解来限制注解的作用目标：
@Target({ElementType.TYPE,ElementType.METHOD})
@interface MyAnn4 {
}
这样MyAnn就只能作用在类和方法上的！其中ElementType.TYPE表示类和接口。
7.注释的保留策略
注解的保留策略是指，注解是只保留在源代码上，还是保留到class文件上，再或者是类在运行时，可以被类加载器加载到内存中。
如果希望注解被反射，那么注解就要保留到运行时，而不是源代码或类文件上。
指定注解的保留策略需要使用元注解@Retention，它有一个value属性，类型为RetentionPolicy类型，RetentionPolicy是枚举类型：
public enum RetentionPolicy {
SOURCE, CLASS, RUNTIME
}
//注解保留到运行时
@Retention(RetentionPolicy.RUNTIME)
//注解可以作用在类或方法上
@Target({ElementType.TYPE, ElementType.METHOD})
@interface MyAnn5{
//String类型的value属性，默认值为hello
String value() default "hello";
//int类型的value1属性，默认值为100
int value1() default 100;
}
8.通过反射读取注解
创建注解类
@Retention(RetentionPolicy.RUNTIME)
@Target({ ElementType.TYPE, ElementType.METHOD })
public @interface MyAnn {
String value() default "hello";
int value1() default 100;
}
}
给类和方法添加注解
@MyAnn(value = "hello world", value1 = 200)
public class MyClass {
private int a;
@MyAnn("myMethod")
public void fun() {
}
}
通过反射读取注解
@Test
public void Demo1() throws Exception {
Class clazz = MyClass.class;
MyAnn myAnn = (MyAnn) clazz.getAnnotation(MyAnn.class);// 获取类上的MyAnn类型的注解
System.out.println(myAnn.value());// 获取value()属性值
System.out.println(myAnn.value1());// 获取value1属性值
Method method = clazz.getMethod("fun");
MyAnn myAnn1 = method.getAnnotation(MyAnn.class);// 获取方法上的MyAnn类型的注解
System.out.println(myAnn1.value());
System.out.println(myAnn1.value1());
}
三、Servlet3.0新特性
1.Servlet3.0新特性概述
Servlete3.0的主要新特性如下三部分：
使用@WebServlet、@WebFilter、@WebListener三个注解来替代web.xml文件中的Servlet、Filter、Listener的配置；
Servlet异步处理：当Servlet处理比较费时的问题时，这会让客户感觉到很卡。当使用异常处理时可以把已经处理好的内容先一步响应给客户端浏览器，然后使用另一个线程来完成费时的操作，也就是把内容一部分一部分的显示出来；
上传组件：不用再使用fileupload等第三方的上传组件，使用Servlet3.0的上传组件会更方便。
2.@WebServlet、@WebFilter、@WebListener
@WebServlet(
urlPatterns={"/AServlet"},
initParams={@WebInitParam(name="paramName",value="paramValue")},
loadOnStartup=1
)
public class AServlet extends HttpServlet {
public void init(ServletConfig config) throws ServletException {
System.out.println(config.getInitParameter("paramName"));
}
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
request.setCharacterEncoding("utf-8");
response.setContentType("text/html;charset=utf-8");
response.getWriter().print("Hello World!");
}
@WebFilter(urlPatterns={"/*"},
dispatcherTypes={DispatcherType.REQUEST, DispatcherType.FORWARD})
public class AFilter implements Filter {
public void destroy() {}
public void doFilter(ServletRequest request, ServletResponse response,
FilterChain chain) throws IOException, ServletException {
System.out.println("start filter");
chain.doFilter(request, response);
System.out.println("end filter");
}
public void init(FilterConfig fConfig) throws ServletException {}
}
@WebListener()
public class AListener implements ServletContextListener {
public void contextDestroyed(ServletContextEvent arg0) {
System.out.println("服务器关闭了");
}
public void contextInitialized(ServletContextEvent arg0) {
System.out.println("服务器启动了");
}
}
3.Servlet异步处理
Servlet异步处理就是让Servlet在处理费时的请求时不要阻塞，而是一部分一部分的显示。
也就是说，在使用Servlet异步处理之后，页面可以一部分一部分的显示数据，而不是一直卡，等到请求响应结束后一起显示。
在使用异步处理之前，一定要在@WebServlet注解中给出asyncSupported=true，不然默认Servlet是不支持异步处理的。如果存在过滤器，也要设置@WebFilter的asyncSupported=true。
@WebServlet(urlPatterns = {"/MyServlet"}, asyncSupported=true)
注意，响应类型必须是text/html，所以：response.setContentType(“text/html;charset=utf-8”);
使用异步处理大致可以分为两步：
（1）Servlet正常响应数据；
（2）Servlet异常响应数据。
在Servlet正常响应数据时，没什么可说的，可通知response.getWriter().print()来向客户端输出，但输出后要使用response.getWriter().flush()刷新，不然数据只是在缓冲区中，不能向客户端发送数据的。
异步响应数据需要使用request.startAsync()方法获取AsyncContext对象。然后调用AsyncContext对象的start()方法启动异步响应，start()方法需要一个Runnable类型的参数。在Runnable的run()方法中给出异步响应的代码。
asyncContext.start(new Runnable() {
public void run() {
for(char i = 'a'; i <= 'z'; i++) {
try {
Thread.sleep(100);
asyncContext.getResponse().getWriter().print(i + " ");
asyncContext.getResponse().getWriter().flush();
} catch (Exception e) {
e.printStackTrace();
}
}
asyncContext.complete();
}
});
Tomcat需要知道异步响应是否结束，如果响应不结束，虽然客户端浏览器会看到响应的数据，但是鼠标上只是有个圈圈的不行的转啊转的，表示还没有结束响应。Tomcat会等待到超时为止，这个超时的时间可以通过AsyncContext类的getTimeout()方法获取，Tomcat默认为20000毫秒。当然也可以通过setTimeOut()方法设置，以毫秒为单位。ac.setTimeout(1000*10)。
如果异步线程已经结束了响应，那么可以在异步线程中调用AsyncContext.complete()方法，这样Tomcat就知道异步线程已经完成了工作了。
4.文件上传
Servlet3.0提供了文件上传的处理方案。只需要在Servlet上添加@MultipartConfig注解即可。
当然也可以为@MultipartConfig注解指定属性值，它有四个属性：
int filesizeThreshold：指定缓存的大小，当超出这个大小后，文件会保存到磁盘上；
String location：指定临时文件的目录；
long maxFilesize：指定上传单个文件的大小限制，如果上传的谁的超出了这个大小，那么就会抛出异常；
long maxRequestSize：指定整个表单的大小限制。
当在Servlet上使用了@MultipartConfig注解后，那么就可以使用request.getPart(“fieldName”)来获取<input:file>的内容，其中Part表示一个文件表单项。
<form action="/a1/UploadServlet" method="post" enctype="multipart/form-data"> 用户名：<input type="text" name="username"/><br/> 照 片：<input type="file" name="file1" /><br/> <input type="submit" value="提交"/> </form>
@WebServlet(urlPatterns={"/UploadServlet"})
@MultipartConfig(maxFileSize=1024 * 1024)
public class UploadServlet extends HttpServlet {
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
request.setCharacterEncoding("utf-8");
response.setContentType("text/html;charset=utf-8");
String username = request.getParameter("username");//还是用原来方法来获取普通表单项的内容
response.getWriter().print("size: " + username + "<br/>");
Part part = request.getPart("file1");//获取文件表单项的内容，返回值为Part
response.getWriter().print("size: " + part.getSize() + "<br/>");//打印文件的大小
response.getWriter().print("type: " + part.getContentType() + "<br/>");//打印文件的类型
response.getWriter().print("name: " + part.getName() + "<br/>");//打印文件表单项的filedName，而不是fileName。
String name = part.getHeader("content-disposition");//获取当前文件表单项的指定头信息
String fileNameTmp = name.substring(name.indexOf("filename=")+10);
//获取上传文件的名称！因为Part没有提供获取fileName的方法，所以需要自己来写方法处理这一问题
String fileName = fileNameTmp.substring(0,fileNameTmp.indexOf("\""));
System.out.println("fileName: " + fileName);
String savepath = this.getServletContext().getRealPath("/uploads");
part.write(savepath + "/" + fileName);//把文件保存到指定路径
}
}