试试

Author: gitking

WebContent/WEB-INF/lib/ojdbc6-11.2.0.4.jar

@@ -4,7 +4,8 @@
   xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
                       http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
   version="3.1"
-  metadata-complete="true">
+  metadata-complete="false">
+  <!-- version="3.1" 这里可以看servlet的版本,servlet3.0必须使用JDK1.6以上版本，tomcat必须是7.0及以上,tomcat6.0不支持 -->
 
   <!--web.xml文件的继承,每个完整的JavaWeb应用中都需要有web.xml,但我们不知道所有的web.xml文件都有一个共同的父文件,它在tomcat的conf/web.xml路径。
   如果一个请求没有任何一个servlet处理,这是就会用到conf/web.xml文件里面的default这个servlet,这个servlet会显示404页面。

WebContent/WEB-INF/web.xml

@@ -22,6 +22,11 @@ public static void main(String[] args) {
 		String sp = "A,B,C,D";
 		String[] ss = sp.split("\\,"); // {"A", "B", "C", "D"}
 		System.out.println("使用split()方法，并且传入的也是正则表达式" + ss);
+		//使用索引访问用String的split方法得到的数组时，需做最后一个分隔符后有无内容的检查，否则会有抛IndexOutOfBoundsException的风险。
+		String str = "a,b,c,,";
+		String[] ary = str.split(",");
+		//预期大于3，结果是3
+		System.out.println(ary.length);
 
 		String[] arr = {"A", "B", "C"};
 		String sar = String.join("***", arr); // "A***B***C"

src/com/yale/test/java/demo/string/StringTest.java

@@ -3,7 +3,6 @@
 /**
  * 泛型接口
  * @author dell
- *
  * @param <T>
  */
 public interface IMessage<T> {

src/com/yale/test/java/fanxing/IMessage.java

@@ -0,0 +1,48 @@
+package com.yale.test.java.fanxing;
+
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+
+/*
+ * 泛型继承
+ * 一个类可以继承自一个泛型类。例如：父类的类型是Pair<Integer>，子类的类型是IntPair，可以这么继承：
+ * 使用的时候，因为子类IntPair并没有泛型类型，所以，正常使用即可：
+ */
+public class IntPair extends Pair<Integer>{
+	public IntPair() {
+		super(11, 22);
+	}
+	
+	public static void main(String[] args) {
+		IntPair ip = new IntPair();
+		/*
+		 * 前面讲了，我们无法获取Pair<T>的T类型，即给定一个变量Pair<Integer> p，无法从p中获取到Integer类型。
+		 * 但是，在父类是泛型类型的情况下，编译器就必须把类型T（对IntPair来说，也就是Integer类型）保存到子类的class文件中，
+		 * 不然编译器就不知道IntPair只能存取Integer这种类型。
+		 * 在继承了泛型类型的情况下，子类可以获取父类的泛型类型。例如：IntPair可以获取到父类的泛型类型Integer。获取父类的泛型类型代码比较复杂：
+		 */
+		Class<IntPair> clazz = IntPair.class;
+		Type t = clazz.getGenericSuperclass();
+		if (t instanceof ParameterizedType) {
+			ParameterizedType pt = (ParameterizedType)t;
+			Type[] types = pt.getActualTypeArguments();//可能有多个泛型类型
+			Type firstType = types[0];//取第一个泛型类型
+			Class<?> typeClass = (Class<?>) firstType;
+			System.out.println("父类的泛型类型为:" + typeClass);
+		}
+		/*
+		 * 因为Java引入了泛型，所以，只用Class来标识类型已经不够了。实际上，Java的类型系统结构如下：
+			                      ┌────┐
+			                      │Type│
+			                      └────┘
+			                         ▲
+			                         │
+			   ┌────────────┬────────┴─────────┬───────────────┐
+			   │            │                  │               │
+			┌─────┐┌─────────────────┐┌────────────────┐┌────────────┐
+			│Class││ParameterizedType││GenericArrayType││WildcardType│
+			└─────┘└─────────────────┘└────────────────┘└────────────┘
+		 */
+		
+	}
+}

src/com/yale/test/java/fanxing/IntPair.java

@@ -2,7 +2,21 @@
 
 public class MesNumber<T extends Number> {//这里不能用super
 	private T node;
+	
+	public MesNumber(Class<T> clazz) throws InstantiationException, IllegalAccessException{
+		/*
+		 * 局限四：不能实例化T类型：
+		 * 要实例化T类型，我们必须借助额外的Class<T>参数：
+		 * 代码借助Class<T>参数并通过反射来实例化T类型，使用的时候，也必须传入Class<T>。例如：
+		 * MesNumber<Integer> pair = new MesNumber<>(Integer.class);
+		 */
+		//node = new T();
+		node = clazz.newInstance();
+	}
 
+	
+	public MesNumber() {
+	}
 	public T getNode() {
 		return node;
 	}

src/com/yale/test/java/fanxing/MesNumber.java

@@ -10,4 +10,17 @@ public T getNode() {
 	public void setNode(T node) {
 		this.node = node;
 	}
+	
+	/*
+	 * 不恰当的覆写方法
+	 * 有些时候，一个看似正确定义的方法会无法通过编译。例如：
+	 * 这是因为，定义的equals(T t)方法实际上会被擦拭成equals(Object t)，而这个方法是继承自Object的，编译器会阻止一个实际上会变成覆写的泛型方法定义。
+	 * 换个方法名，避开与Object.equals(Object)的冲突就可以成功编译：
+	 */
+//	public boolean equals(T t) {
+//        return this == t;
+//    }
+	public boolean same (T t) {
+	  return this == t;
+	}
 }

src/com/yale/test/java/fanxing/MesSuper.java

@@ -74,15 +74,20 @@ public static void main(String[] args) {
 
 		ArrayList<String> al = new ArrayList<String>();
 		ArrayList<Float> alf = new ArrayList<Float>();
-		if (al.getClass() == alf.getClass()) {
+		if (al.getClass() == alf.getClass()) {//局限二：无法取得带泛型的Class。观察以下代码：
 			/**
 			 * 运行期间无法获取泛型实际类型
 			 * 由于编译之后，泛型就被擦除，所以在代码运行期间，Java 虚拟机无法获取泛型的实际类型。
 			 * 上面这段代码，从源码上两个 List 看起来是不同类型的集合，但是经过泛型擦除之后，集合都变为 ArrayList。所以 if语句中代码将会被执行。
+			 * 换句话说，所有泛型实例，无论T的类型是什么，getClass()返回同一个Class实例，因为编译后它们全部都是Pair<Object>。
 			 */
 			System.out.println("运行期间无法获取泛型实际类型");
 		}
 
+		//局限三：无法判断带泛型的类型：
+		//if (al instanceof ArryList<String>) {//编译报错,原因和前面一样，并不存在ArryList<String>.class，而是只有唯一的ArryList.class。
+		//}
+	
 
 		System.out.println("泛型总结:泛型的缺点:1,由于需要向后兼容,导致泛型会在编译后将泛型擦除。2,运行效率低,由于不支持");
 		System.out.println("泛型总结:泛型的缺点:2,由于泛型擦除后,原来的泛型就变成Object类了,所以泛型没办法支持基本类型,因为基本类型int,long不能向上转型为Object类型。");

src/com/yale/test/java/fanxing/Message.java

@@ -2,8 +2,10 @@
 
 /**
  * 泛型类型只允许引用类型(类和接口,不能使用基本数据类型)
+ * 编写泛型类比普通类要复杂。通常来说，泛型类一般用在集合类中，例如ArrayList<T>，我们很少需要编写泛型类。
+ * T extends Number意思是所有泛型类型为Number或Number子类
+ * 这种使用<? extends Number>的泛型定义称之为上界通配符（Upper Bounds Wildcards），即把泛型类型T的上界限定在Number了。
  * @author dell
- *
  * @param <T>
  */
 public class MessageNumberImpl<T extends Number> implements IMessage<T> {

src/com/yale/test/java/fanxing/MessageNumberImpl.java

@@ -0,0 +1,27 @@
+package com.yale.test.java.fanxing;
+
+public class Pair<T> {
+	private T first;
+	private T last;
+	
+	public Pair(T first, T last) {
+		this.first = first;
+		this.last = last;
+	}
+
+	public T getFirst() {
+		return first;
+	}
+
+	public void setFirst(T first) {
+		this.first = first;
+	}
+
+	public T getLast() {
+		return last;
+	}
+
+	public void setLast(T last) {
+		this.last = last;
+	}
+}