-------android培训、java培训、期待与您交流! ----------
package cn.itcast.day2;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Date;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Map;
import java.util.Set;
import java.util.Vector;
import cn.itcast.day1.ReflectPoint;
public class GenericTest
{
/**
* @param args
* @throws NoSuchMethodException
* @throws SecurityException
* @throws InvocationTargetException
* @throws IllegalAccessException
* @throws InstantiationException
* @throws IllegalArgumentException
* @throws ClassNotFoundException
*/
public static void main(String[] args) throws SecurityException, NoSuchMethodException, IllegalArgumentException, InstantiationException, IllegalAccessException, InvocationTargetException, ClassNotFoundException
{
ArrayList collection1 = new ArrayList();
collection1.add(1);
collection1.add(2L);
collection1.add("abc");
int i = (Integer) collection1.get(0);
//int i = (int) collection1.get(0);
ArrayList<String> collection2 = new ArrayList<String>();
//collection2.add(1); // is not applicable for the argument
//collection2.add(2L);
collection2.add("abc");
String s = collection2.get(0);
// new String(new StringBuffer("abc");
//带泛型的反射
Constructor<String> constructor1 =
String.class.getConstructor(StringBuffer.class);
String str1 = constructor1.newInstance(new StringBuffer("abc"));
System.out.println(str1.charAt(2));
//Generic type retent at the source only.
ArrayList<Integer> collection3 = new ArrayList<Integer>();
System.out.println(collection3.getClass() == collection2.getClass());//true
//collection3.add("abc") by reflect
Method methodAdd = collection3.getClass().getMethod("add", Object.class);
boolean retVal = (Boolean)methodAdd.invoke(collection3, "abc");
System.out.println(retVal);
Object str2 = collection3.get(0);
System.out.println(str2);
printCollection(collection3);
printCollection2(collection3);
//Class<? extends Number> x = Object.class.asSubclass(Number.class);//compile ok, but run err
Class<? extends Number> x = Number.class.asSubclass(Number.class);//run ok
Class<?> y;
//Class<String> x1 = Class.forName("java.lang.String");//Compile err
Class<?> x1 = Class.forName("java.lang.String");//Compile OK
Class<String> x2 = (Class<String>) Class.forName("java.lang.String");//Compile OK
HashMap<String,Integer> maps = new HashMap<String,Integer>();
maps.put("a",28);
maps.put("b",21);
maps.put("c",38);
Set<String> set = maps.keySet();
for(String key : set)
{
System.out.println(key+":"+maps.get(key));
}
Set<Map.Entry<String, Integer>> entrySet = maps.entrySet();
for(Map.Entry<String, Integer> entry: entrySet)
{
System.out.println(entry.getKey()+":"+entry.getValue());
}
//泛型应用
add(3,5);
Number x11 = add(3.5, 3); //在Number 范围内 double 与 int可相加
Object x22 = add(3, "abc"); //在Object范围内int 与 String 相加
swap(new String[]{"abc", "xyz", "whb"}, 1, 2);
swap(new Integer[]{100, 300, 200}, 1, 2);
Object obj = "abc";
String str3 = autoConvertType(obj);
//泛型推演
copy1(new Vector<String>(), new String[10]);
copy2(new Date[10], new String[10]);//!define one generic type is enough.
//copy1(new Vector<Date>(), new String[10]);// err. not applicable for the argument
//泛型在DAO中的应用
GnericDAO<ReflectPoint> dao = new GnericDAO<ReflectPoint>();
dao.add(new ReflectPoint(3, 5));
//String e = dao.findById(1); //type err can be prompted when compilling
ReflectPoint e = dao.findById(1);
//Vector<Date> v1 = new Vector<Date>();
Method applyMethod = GenericTest.class.getMethod("applyVector", Vector.class);
Type[] types = applyMethod.getGenericParameterTypes();//得到方法上的类型定义,其中包含泛型
for(Type type : types)
{
if(type instanceof ParameterizedType)
{
ParameterizedType pType = (ParameterizedType)type;
System.out.println(pType.getRawType());//this type is in the class file
System.out.println(pType.getOwnerType());
System.out.println(Arrays.toString(pType.getActualTypeArguments()));
}
System.out.println();
System.out.println(type.getClass());
}
//HashMap<String,Date> h1 = new HashMap<String, Date>();
//Class clazz1 = HashMap<String,Date>.class;//complie error
Class clazz2 = HashMap.class;
//Class clazz3 = ArrayList<String>.class;//complie error
Class clazz4 = ArrayList.class;
Method applyMethod2 = GenericTest.class
.getMethod("applyVector2", HashMap.class, Integer.class, Object.class);
Type[] types2 = applyMethod2.getGenericParameterTypes();//得到方法上的类型定义,其中包含泛型
for(Type type : types2)
{
System.out.println("<---------");
if(type instanceof ParameterizedType)
{
ParameterizedType pType = (ParameterizedType)type;
System.out.println("rawType:"+pType.getRawType());//this type is in the class file
System.out.println("ownerType:"+pType.getOwnerType());
System.out.println(Arrays.toString(pType.getActualTypeArguments()));
}
System.out.println("type class:"+type.getClass());
System.out.println("----------->");
}
//parameterized arguments was stored in the Method Object.
/*
<---------
rawType:class java.util.HashMap
ownerType:null
[class java.lang.String, class java.util.Date]
type class:class sun.reflect.generics.reflectiveObjects.ParameterizedTypeImpl
----------->
<---------
type class:class java.lang.Class
----------->
<---------
type class:class sun.reflect.generics.reflectiveObjects.TypeVariableImpl
----------->
*/
}
public static void applyVector(Vector<Date> v1)
{
}
public static <T> void applyVector2(HashMap<String,Date> h, Integer i, T t)
{
}
private static <T> void copy2(T[] dates, T[] strings)
{
}
private static <T> void copy1(Vector<T> vector, T[] strings)
{
}
private static <T> T autoConvertType(Object obj)
{
return (T)obj;
}
private static <T> void swap(T[] array, int i, int j)
{
T temp = array[i];
array[i] = array[j];
array[j] = temp;
}
private static <T> T add(T i, T j)//泛型定义要加《》,而使用则无须
{
return null;
}
private static void printCollection(Collection<?> collection3)//? denote type is unkonw
{
/*T t = (T)new Object();
collection.add(t);*/
System.out.println(collection3.size());
for(Object obj : collection3)
{
System.out.println(obj);
}
}
private static <T> void printCollection2(Collection<T> collection)//? denote type is unkonw
{
/*T t = (T)new Object();
collection.add(t);*/
System.out.println(collection.size());
for(Object obj : collection)
{
System.out.println(obj);
}
}
}