内省的简单运用:
JavaBean是一种特殊的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 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 collection2 = new ArrayList();
//collection2.add(1);
//collection2.add(1L);
collection2.add("abc");
String element = collection2.get(0);
//new String(new StringBuffer("abc"));
Constructor constructor1 = String.class.getConstructor(StringBuffer.class);
String str2 = constructor1.newInstance(/*"abc"*/new StringBuffer("abc"));
System.out.println(str2.charAt(2));
ArrayList collection3 = new ArrayList();
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 x = String.class.asSubclass(Number.class);
Class> y;
Class x ;//Class.forName("java.lang.String");
HashMap maps = new HashMap();
maps.put("zxx", 28);
maps.put("lhm", 35);
maps.put("flx", 33);
Set> entrySet = maps.entrySet();
for(Map.Entry 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(),new String[10]);
copy2(new Date[10],new String[10]);
//copy1(new Vector(),new String[10]);//类型摧断具有传播性
GenericDao dao = new GenericDao();
dao.add(new ReflectPoint(3,3));
//String s = dao.findById(1);
//Vector v1 = new Vector();
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 v1){
}
private static void fillArray(T[] a,T obj){
for(int i=0;i T autoConvert(Object obj){
return (T)obj;//定义一个泛型方法,自动将Object类型的对象转变成其他类型。
}
private static void swap(T[] a,int i,int j){
T tmp = a[i];
a[i] = a[j];
a[j] = tmp;
}
private static 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 void printCollection2(Collection collection){
//collection.add(1);
System.out.println(collection.size());
for(Object obj : collection){
System.out.println(obj);
}
}
public static void copy1(Collection dest,T[] src){
//定义一个方法,把任意参数类型的集合中的数据安全地复制到相应类型的数组中。
for(int i=0;i void copy2(T[] dest,T[] src){
//定义一个方法,把任意参数类型的一个数组中数据安全复制到相应类型的另一个数组中。
}
}
import java.util.Set;
//dao data access object--->crud
public class GenericDao {
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 void update2(E obj){
}
public E findByUserName(String name){
return null;
}
public Set findByConditions(String where){
return null;
}
}