Java基础---Java---基础加强---内省的简单运用、注解的定义与反射调用、 自定义注解及其应用、泛型及泛型的高级应用、泛型集合的综合

import java.beans.BeanInfo;
import java.beans.IntrospectionException;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.sql.Date;
import java.util.Map;

import org.apache.commons.beanutils.BeanUtils;
import org.apache.commons.beanutils.PropertyUtils;

/**
* 内省的简单运用。
* @author hjl
*
*/
public class IntroSpectorTest {

public static void main(String[] args) throws Exception {

ReflectPoint pt1=new ReflectPoint(3, 5);
String propertyName="x";
//"x"--->"X"-->"getX"--->"MethodGexX"-->
Object retVal = getProperty(pt1, propertyName);
System.out.println(retVal);

Object value =7;
setProperties(pt1, propertyName, value);

System.out.println(BeanUtils.getProperty(pt1,"x").getClass());

BeanUtils.setProperty(pt1, "x", "9");

System.out.println(pt1.getX());

//java7新特性
/*
Map<K, V> map=(name:"hjl",age:18);
BeanUtils.setProperty(map, "name", "lhm");
*/
BeanUtils.setProperty(pt1,"birthday.time", "111");

System.out.println(BeanUtils.getProperty(pt1, "birthday.time"));

PropertyUtils.setProperty(pt1,"x", 9);
System.out.println(PropertyUtils.getProperty(pt1, "x").getClass());
}

private static void setProperties(Object pt1, String propertyName,
Object value) throws IntrospectionException,
IllegalAccessException, InvocationTargetException {
PropertyDescriptor pd2=new  PropertyDescriptor(propertyName, pt1.getClass());
Method methodSetX=pd2.getWriteMethod();//得到属性的get方法。
methodSetX.invoke(pt1,value);
}

private static Object getProperty(Object pt1, String propertyName)
throws IntrospectionException, IllegalAccessException,
InvocationTargetException {
//		PropertyDescriptor pd=new  PropertyDescriptor(propertyName, pt1.getClass());
//		Method methodGetX=pd.getReadMethod();//得到属性的get方法。
//		Object retVal=methodGetX.invoke(pt1);
//		return retVal;

BeanInfo beanInfo=Introspector.getBeanInfo(pt1.getClass());
PropertyDescriptor[] pds=beanInfo.getPropertyDescriptors();
Object retVal=null;
for(PropertyDescriptor pd:pds){
if(pd.getName().equals(propertyName)){
Method methodGetX=pd.getReadMethod();
retVal=methodGetX.invoke(pt1);
break;
}
}

return retVal;
}
}

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import day01.EnumTest;

//元注解
//元数据
//元信息
@Retention(RetentionPolicy.RUNTIME)//注解的注解，是为这个注解服务的。
//这个让注解保留在运行阶段
@Target({ElementType.METHOD,ElementType.TYPE})
public @interface Annotation {

String color() default "blue";
String value();
int [] arrayAttr() default {3,4,4};
EnumTest.TrafficLamp lamp() default EnumTest.TrafficLamp.Red;
MetaAnnotation annotationAttr() default @MetaAnnotation("ssh");
}

/**
*
* @author hjl
*
*/
@Annotation(annotationAttr=@MetaAnnotation("ssID"), color="red",value="haha",arrayAttr=1)
public class AnnotationTest {

@SuppressWarnings("deprecation")
//@Annotation("haha")
public static void main(String[] args) throws Exception {
System.runFinalizersOnExit(true);
//对一个类进行检查，利用反射
if(AnnotationTest.class.isAnnotationPresent(Annotation.class)){
Annotation annotation=(Annotation) AnnotationTest.class.getAnnotation(Annotation.class);
//为什么用type,因为type中包含了class,type中有许多class
//这个类的实例对象是通过反射找到的。
System.out.println(annotation);
System.out.println(annotation.color());
System.out.println(annotation.arrayAttr().length);
System.out.println(annotation.lamp().nextLamp());
System.out.println(annotation.annotationAttr().value());
}
}

//对于那些过时的方法，我们可以进它进行注解，以便编译器还能编译
@Deprecated //表示过时
public static void sayHello(){
System.out.println("hello,world!");
}
}

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.Vector;

import day01.ReflectPoint;

public class GenericTest {

/**
* @param args
*/
public static void main(String[] args) throws Exception {
// TODO Auto-generated method stub
ArrayList collection1 = new ArrayList();
collection1.add(1);
collection1.add(1L);
collection1.add("abc");
//int i = (Integer)collection1.get(1);

ArrayList<String> collection2 = new ArrayList<String>();
//collection2.add(1);
//collection2.add(1L);
collection2.add("abc");
String element = collection2.get(0);

//new String(new StringBuffer("abc"));
Constructor<String> constructor1 = String.class.getConstructor(StringBuffer.class);
String str2 = constructor1.newInstance(/*"abc"*/new StringBuffer("abc"));
System.out.println(str2.charAt(2));

ArrayList<Integer> collection3 = new ArrayList<Integer>();
System.out.println(collection3.getClass() == collection2.getClass());
//collection3.add("abc");
collection3.getClass().getMethod("add", Object.class).invoke(collection3, "abc");
System.out.println(collection3.get(0));

printCollection(collection3);

//Class<Number> x = String.class.asSubclass(Number.class);
Class<?> y;
Class<String> x ;//Class.forName("java.lang.String");

HashMap<String,Integer> maps = new HashMap<String, Integer>();
maps.put("zxx", 28);
maps.put("lhm", 35);
maps.put("flx", 33);

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 x1 = add(3.5,3);//前面为什么是Number，因为float，int的交集是Number
Object x2 = add(3,"abc");

swap(new String[]{"abc","xyz","itcast"},1,2);
//swap(new int[]{1,3,5,4,5},3,4);//泛型的类型，只能是引用类型，不能是基本类型
//只有引用类型才能作为泛型方法的实际参数。这是基于自动装箱，拆箱的功能，
//本身如果就是基本类型的话，本身如果要的就是这种基本类型的话，如果装箱的话，就是多此一举了
Object obj = "abc";
String x3 = autoConvert(obj);

copy1(new Vector<String>(),new String[10]);
copy2(new Date[10],new String[10]);
//copy1(new Vector<Date>(),new String[10]);//类型摧断具有传播性

GenericDao<ReflectPoint> dao = new GenericDao<ReflectPoint>();
dao.add(new ReflectPoint(3,3));
//String s = dao.findById(1);

//Vector<Date> v1 = new Vector<Date>();
Method applyMethod = GenericTest.class.getMethod("applyVector", Vector.class);
Type[] types = applyMethod.getGenericParameterTypes();
ParameterizedType pType = (ParameterizedType)types[0];
System.out.println(pType.getRawType());
System.out.println(pType.getActualTypeArguments()[0]);
}

public static void applyVector(Vector<Date> v1){

}

private static <T> void fillArray(T[] a,T obj){
for(int i=0;i<a.length;i++){
a[i] = obj;//定义一个方法，可以将任意类型的数组中的所有元素填充为相应类型的某个对象。
}
}
private static <T> T autoConvert(Object obj){
return (T)obj;//定义一个泛型方法，自动将Object类型的对象转变成其他类型。
}
private static <T> void swap(T[] a,int i,int j){
T tmp = a[i];
a[i] = a[j];
a[j] = tmp;
}

private static <T> T add(T x,T y){
//声明了一个新的类型，T x,T y是把T这种类型的变量与另一个T类型的变量进行相加
//返回的结果还是T这种类型的结果。在返回值之前，我们用<>来说明这种类型
return null;
}

public static void printCollection(Collection<?> collection){
//collection.add(1);
System.out.println(collection.size());
for(Object obj : collection){
System.out.println(obj);
}
}

public static <T> void printCollection2(Collection<T> collection){
//collection.add(1);
System.out.println(collection.size());
for(Object obj : collection){
System.out.println(obj);
}

}

public static <T> void copy1(Collection<T> dest,T[] src){
//定义一个方法，把任意参数类型的集合中的数据安全地复制到相应类型的数组中。
for(int i=0;i<src.length;i++){
dest.add(src[i]);
}
}

public static <T> void copy2(T[] dest,T[] src){
//定义一个方法，把任意参数类型的一个数组中数据安全复制到相应类型的另一个数组中。
}
}

import java.util.Set;

//dao data access object--->crud
public class GenericDao<E>  {
public void add(E x){

}

public E findById(int id){
return null;
}

public void delete(E obj){

}

public void delete(int id){

}

public void update(E obj){

}

public static <E> void update2(E obj){

}

public E findByUserName(String name){
return null;
}
public Set<E> findByConditions(String where){
return null;
}
}