java 自学日志【二十】---基础加强DAY27上

public static void setProperty(Object pt1, String propertyName,
Object value) throws IntrospectionException,
IllegalAccessException, InvocationTargetException {
PropertyDescriptor dp1 = new PropertyDescriptor(propertyName,pt1.getClass());
Method methodSetX = dp1.getWriteMethod();
methodSetX.invoke(pt1,value);
}
--------------------------------------------
public static Object getProperty(Object pt1, String propertyName)
throws IntrospectionException, IllegalAccessException,
InvocationTargetException {
PropertyDescriptor dp = new PropertyDescriptor(propertyName,pt1.getClass());
Method methodGetX = dp.getReadMethod();
Object retVal = methodGetX.invoke(pt1);
return retVal;
}
--------------------------------------------
ReflectPoint pt1 = new ReflectPoint(1,1);
String propertyName = "x";
Object retVal = getProperty(pt1, propertyName);
System.out.println("getX："+retVal);
Object value = 7;

setProperty(pt1, propertyName, value);
System.out.println("setX:"+pt1.getX());

public static Object getProperty(Object pt1, String propertyName)
throws IntrospectionException, IllegalAccessException,
InvocationTargetException {
BeanInfo beanInfo = Introspector.getBeanInfo(pt1.getClass());
PropertyDescriptor[] dps = beanInfo.getPropertyDescriptors();
Object retVal = null;
for(PropertyDescriptor dp:dps)
{
if(dp.getName().equals(propertyName)){
retVal = dp.getReadMethod().invoke(pt1);
break;
}
}
return retVal;

ReflectPoint pt1 = new ReflectPoint(1,1);
BeanUtils.setProperty(pt1, "x", 25);
System.out.println(BeanUtils.getProperty(pt1, "x").getClass().getName());
//BeanUtils可以实现属性链操作
BeanUtils.setProperty(pt1, "date.time", "111");//time不一定在类中存在，只是说明date有getTime和setTime方法。
System.out.println(BeanUtils.getProperty(pt1, "date.time"));
<span style="font-size:14px;">      PropertyUtils.setProperty(pt1, "x", 160);
System.out.println(PropertyUtils.getProperty(pt1, "x").getClass().getName());

import cn.itcast.day1.EnumTest;
@ItcastAnnotation(lamp=EnumTest.TrafficLamp.GREEN,color = "GREEN",value="123",arrayAttri={1,5,8},annoAttr=@MetaAnnotation("flx"))
public class AnnotationTest {

@SuppressWarnings("deprecation")//提示过时了
@ItcastAnnotation("123")
public static void main(String[] args) {
// TODO Auto-generated method stub
System.runFinalizersOnExit(true);
//方法过时了,在dos命令窗口中，如果没有加@SuppressWarnings("deprecation")会提示方法过时，如果有则不提示。

if(AnnotationTest.class.isAnnotationPresent(ItcastAnnotation.class)){
ItcastAnnotation annotation = AnnotationTest.class.getAnnotation(ItcastAnnotation.class);
System.out.println(annotation);
System.out.println(annotation.color());
System.out.println(annotation.value());
System.out.println(annotation.arrayAttri().length);
System.out.println(annotation.lamp().nextLamp());
System.out.println(annotation.annoAttr().value());
}

}
@Deprecated//过时了
public static void sayHello()
{
System.out.println("hi,java！");
}

}

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import cn.itcast.day1.EnumTest;
/*
* .class文件不是字节码文件，class文件通过类加载器，进入内存后，内存中存在的才是字节码文件。
*/
@Retention(RetentionPolicy.RUNTIME)//Retention是元注解：对注解的注解
@Target({ElementType.METHOD,ElementType.TYPE})
public @interface ItcastAnnotation {
String color() default "red";
String value();
int[] arrayAttri() default {1,2,3};
EnumTest.TrafficLamp lamp() default EnumTest.TrafficLamp.RED;
MetaAnnotation annoAttr()  default @MetaAnnotation("yxf");

}

public @interface MetaAnnotation {
String value() ;
}

//没有使用泛型：
ArrayList collection = new ArrayList();
collection.add(1);
collection.add(1L);
collection.add("abc");
//      int i = （Integer）collection.get(1);//这句会报错</span>
//使用泛型的代码：

//      在集合中的应用
ArrayList<String> collection1 = new ArrayList<String>();
//      collection1.add(1);
//      collection1.add(1L);
collection1.add("String");
String i = collection1.get(0);//        在反射中的应用
//用反射实现操作：String str = 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));

ArrayList<Integer> collection2 = new ArrayList<Integer>();
System.out.println(collection1.getClass()==collection2.getClass());
collection2.add（“123”）；//这句会报错
collection2.getClass().getMethod("add", Object.class).invoke(collection2, "hello");
System.out.println(collection2.get(0)); //结果却为hello

Collection<String> c = new Vector();
Collection c1 =  new Vector<String>();
//      见第4条
//错误语句  Vector<String> v=new Vector<Object>();
//错误语句  Vector<Object> v1=new Vector<String>();
Vector  v2=new Vector<String>();
Vector<Object> v3 = v2;

//错误语句  Vector <Integer>  [] vectorList = new Vector <Integer>[10];//见第5条。
Vector <Integer[]>   vectorList = new Vector <Integer[]>();

printCollection_2(collection2);
//      Class<Number> x = String.class.asSubclass(Number.class);//错误。
//      Class x1 = String.class.asSubclass(Number.class);
//      Class<String> y = Class.forName("java.lang.String");//错误
Class y = Class.forName("java.lang.String");//要抛出异常。
Class<?> y1;
Class<String> y2 = null;
y1=y2;
//      y2=y1;

HashMap<String,Integer> hm = new HashMap<String,Integer>();
hm.put("zyq", 18);
hm.put("zsy", 49);
hm.put("zyx", 25);

Set<Map.Entry<String,Integer>> entrySet = hm.entrySet();
for(Map.Entry<String, Integer> entry:entrySet){
System.out.println(entry.getKey() + ":" + entry.getValue());
}

add(1,2);
Number x1 = add(1,1.4);//int 和float的最大公共集是Number
Object x2 = add(1,"abc");//String 和int的最大公共集是Object

private static<T> T add(T x,T y){//取得的T是 x 和  y的最大公共集，其实也是java中多态的体现。
return null;
}

swap(new String[]{"abc","123","hello"},0,1);
//      swap(int[]{1,2,3,4},2,3);//int是基本数据类型，所以不能实现。
[java] view plaincopy
private static<T> void swap(T[] t ,int x,int y){
T temp = t[x];
t[x] = t[y];
t[y] = temp;
}

ArrayList<Integer> al = new ArrayList<Integer>();
al.add((Integer)autoConvert(345));
System.out.println(al.get(0));

String s = autoConvert("123");
System.out.println(s);
fillArray(new Integer[]{1,3,4},1);

copy1(new Vector<String>(), new String[]{"123","5674"});
copy2(new Date[20], new String[10]);//这个是两个取交集。
//      copy1(new Vector<Date>(), new String[]{"123","5674"});
//类型推断的传播性，Vector中T已经指定为Date，后边的T也应该是Date，否则报错。

public static<T> void fillArray(T[] t,T obj){
for(int x= 0;x<t.length;x++){
t[x]= obj;
}
}
public static <T> T autoConvert(Object obj){
return (T)obj;
}

public static <T>void copy1(Collection<T> des ,T[] src){

}
public static <T>void copy2(T[] des ,T[] src){

}

import java.util.Set;
//dao data access object:CRUD
public class GenericDao<E> {
//增
public void add(E x){

}
//删
public void delete(int id){

}
public void delete(E obj){

}
//查
public E findByID(int id){
return null;
}
public E findByName(String name){
return null;
}

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

//改
public void update(E obj){

}
public static<E> void update1(E obj){//静态方法不能用类上定义的泛型参数，但可以自己定义泛型,这里的E和类上的E是两码事。

}
}
GenericDao<ReflectPoint> dao = new GenericDao<ReflectPoint>();
dao.add(new ReflectPoint(5, 7));
//      String s = dao.findByID(1);//返回的也必须是ReflectPoint

import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.Date;
import java.util.Vector;
class GenericTest {
public static void main(String[] args) throws Exception{
Method applyMethod =  GenericTest.class.getMethod("applyVector", Vector.class);
Type[] types =applyMethod.getGenericParameterTypes();
ParameterizedType pType =(ParameterizedType) types[0];

System.out.println(pType.getClass());
System.out.println(pType.getOwnerType());
System.out.println(pType.getRawType());
System.out.println(pType.getActualTypeArguments()[0]);
}

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

}
/*
public static void applyVector(Vector<Integer> v){ //这个方法和上边的方法是同一个方法。

}*/
}