java的反射机制2

四、成员方法的反射（Method类）getMethod();

 

一》反射成员方法格式：

Method method = String.Class.getMethod(“charAt”,parameterType);

Method类  反射名 = 字节码.getMethod（“方法名”，参数列表）；

注意：参数类型用class对象表示；

二》通过反射方法得到字节码里面的方法，再拿着方法作用于某个对象。

 

String str = "abcd";
  //反射格式
  Method methodCharAt = String.class.getMethod("charAt", int.class);
  //调用方法invoke是方法对象的方法（methodCharAt）；
  System.out.println(methodCharAt.invoke(str, 3));
  //如果对象参数为null，说明这个方法时静态的；
  //System.out.println(methodCharAt.invoke(null, 3));

应用：调用某个类的Main方法：

public class ReflectMain {

 /**
  * @param args
  */
 public static void main(String[] args)throws Exception {
  // TODO Auto-generated method stub
  //为什么要用反射的方式掉用main方法，直接类名.Main（new String[]{"111","222","444"}）；
  //因为我们可能不知道用户给我们传递的是那个类的main方法
  //假设args的第一个元素就是那个类名；
  String startClassName = args[0];
  Method mainMethod = Class.forName(startClassName).getMethod("main", String[].class);
  //因为main是static，不通过对象调用，所一null
  mainMethod.invoke(null,(Object) new String[]{"111","222"});
 }

}
class TestArguments
{
 public static void main(String[] args)
 {
  for(String arg : args)
  {
   System.out.println(arg);
  }
 }
}

五、数组的反射应用

一》数组的反射： 

相同元素类型和相同维度（一维和二维）的两个数组的字节码类文件相等，也就是同一份字节码；

 

1.数组与Object的关系

//数组与Object的关系
 public static void arrayMethod()
 {
  int[] arr1 = new int[]{1,2,3};
  int[] arr2 = new int[4];
  int[][] arr3 = new int[2][3];
  String[] arr4 = new String[]{"a","b","c"};
  //相同元素类型和相同维度（一维和二维）的两个数组的字节码类文件相等，也就是同一份字节码；
  System.out.println(arr1.getClass() == arr2.getClass()); //true 相同元素类型，相同维度
  System.out.println(arr1.getClass() == arr3.getClass());//false 相同元素类型，不同维度
  System.out.println(arr1.getClass() == arr4.getClass());//false 不同元素类型，相同维度
  //输出当前数组名称
  System.out.println(arr1.getClass().getName());
  //输出父类名称
  System.out.println(arr1.getClass().getSuperclass().getName());//Object
  System.out.println(arr4.getClass().getSuperclass().getName()); //Object
  //所以数组的父类对象是Objec,因为数组是引用类型
  Object obj1 = arr1;
  Object obj2 = arr3;
  Object obj3 = arr4;
  //因为基本数据类型（int）不能转换Object数组
  //Object[] obj4 = arr1;
  //因为int[]是Object，而int[][] ==Object[]
  Object[] obj5 = arr3;
  //String也是Object，顾String[] == Object【】；
  Object[] obj6 = arr4;
  //数组不能直接打印，可以遍历，而list列表可以直接打印
  //Arrays工具类中asList方法将数组转换成List
  //因为asList（Object【】 obj）；跟int【】不匹配，
  System.out.println(Arrays.asList(arr1));
  System.out.println(Arrays.asList(arr4));
 }

打印数组：

public static void arrayReflect(Object obj)
 {
  Class clazz = obj.getClass();
  //取出字节码，判断是否是数组
  if(clazz.isArray())
  {
   //得到某个数组对象的长度Array.getLength(obj)
   int len = Array.getLength(obj);
   for(int i=0;i<len;i++)
   {
    //获取数组对象的第i个元素Array.get(obj, i)；
    System.out.println(Array.get(obj, i));
   }
  }
  else
  {
   System.out.println(obj);
  }
 }

 

框架的概念及用反射技术开发框架的原理，读取配置文件

config.properties中编写：className = java.util.ArrayList

public class ReflectProper {

 /**
  * @param args
  */
 public static void main(String[] args)throws Exception {
  // TODO Auto-generated method stub
  //InputStream is = new FileInputStream("src/cn/itcast/day1/config.properties");
  //利用类加载器的方式加载配置文件，但这种方式只能读，不能写，OUtputstream；
  //InputStream is = ReflectProper.class.getClassLoader().getResourceAsStream("cn/itcast/day1/config.properties");
  //类加载器的方式还可以简写成；这种方式，路径是以当前包为标准；底层也是调用getClassLoader（）；
  InputStream is = ReflectProper.class.getResourceAsStream("config.properties");
  Properties props = new Properties();
  //将流中的数据加载到集合中
  props.load(is);
  is.close();
  //获取集合中key对应的值
  String className = props.getProperty("className");
  //class.forName（className）
  //就是得到java.util.ArrayList的字节码类，调用newInstance（）创建对象，
  //返回集合对象Collection
  Collection collections = (Collection)Class.forName(className).newInstance();
  ReflectPoint pt1 = new ReflectPoint(3,3);
  ReflectPoint pt2 = new ReflectPoint(5,5);
  ReflectPoint pt3 = new ReflectPoint(3,3);
  collections.add(pt1);
  collections.add(pt2);
  collections.add(pt3);
  collections.add(pt1);
  System.out.println(collections.size());
 }

}

ReflectPoint类编写；

public class ReflectPoint {
 private int x;
 public int y;
 public ReflectPoint(int x, int y) {
  super();
  this.x = x;
  this.y = y;
 }
 
 @Override
 public int hashCode() {
  System.out.println("hashcode");
  final int prime = 31;
  int result = 1;
  result = prime * result + x;
  result = prime * result + y;
  return result;
  
 }

 @Override
 public boolean equals(Object obj) {
  System.out.println("equals");
  if (this == obj)
   return true;
  if (obj == null)
   return false;
  if (getClass() != obj.getClass())
   return false;
  final ReflectPoint other = (ReflectPoint) obj;
  if (x != other.x)
   return false;
  if (y != other.y)
   return false;
  return true;
 }
}