A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

© 酱爆 高级黑马   /  2013-10-7 16:35  /  1929 人查看  /  7 人回复  /   0 人收藏 转载请遵从CC协议 禁止商业使用本文

本帖最后由 酱爆 于 2013-10-8 15:29 编辑

  1. package cn.itcast.day1;

  2. import java.lang.reflect.Array;
  3. import java.lang.reflect.Constructor;
  4. import java.lang.reflect.Field;
  5. import java.lang.reflect.Method;
  6. import java.util.Arrays;
  7. import java.util.*;

  8. public class ReflectTest {

  9.         /**
  10.          * @param args
  11.          */
  12.         public static void main(String[] args) {
  13.                 // TODO Auto-generated method stub
  14.                 try
  15.                 {
  16.                         String str1 = "abc";

  17.                         Class cla1 = str1.getClass();
  18.                         Class cla2 = String.class;
  19.                         Class cla3 = Class.forName("java.lang.String");
  20.                         
  21.                         System.out.println(cla1 == cla2); // true  都是同样的字节码
  22.                         System.out.println(cla1 == cla3); // true
  23.                         
  24.                         System.out.println(cla1.isPrimitive()); // false  判断是否为基本类型
  25.                         
  26.                         System.out.println(int.class.isPrimitive()); // true int是基本类型
  27.                         
  28.                         System.out.println(int.class == Integer.class); // false  int为基本类型,Integer不是基本类型
  29.                         
  30.                         System.out.println(int.class == Integer.TYPE);  //true
  31.                         
  32.                         System.out.println(int[].class.isPrimitive());  // false
  33.                         
  34.                         System.out.println(int[].class.isArray());  // true
  35.                         
  36.                         //需要注意的是,这两个方法都需要类型,getConstructor需要的是的类型而newInstance需要的是相同类型的对象
  37.                         Constructor ct1 = String.class.getConstructor(StringBuffer.class);  // 通过参数的个数来确定哪个构造方法
  38.                         String str2 = (String)ct1.newInstance(new StringBuffer("abc"));
  39.                         System.out.println(str2);
  40.                         
  41.                         
  42.                         ReflectPoint pt1 = new ReflectPoint(3,5);
  43.                         
  44.                         Field fieldY = pt1.getClass().getField("y");
  45.                         System.out.println(fieldY.get(pt1));  // fieldY只是对应的字节码,不是对象,要得到对象的值可以用get()方法获取
  46.                         
  47.                         //Field filedX = pt1.getClass().getField("x");  //error 因为x是私有的,所以不能直接访问
  48.                         
  49.                         Field filedX = pt1.getClass().getDeclaredField("x");//OK
  50.                         
  51.                         //System.out.println(filedX.get(pt1));  // x是私有的,不能直接使用 可以用setAccessible(true)方法
  52.                         filedX.setAccessible(true);
  53.                         System.out.println(filedX.get(pt1));

  54.                         changeStringValue(pt1);
  55.                         System.out.println(pt1);

  56.                         Method methodCharAt = String.class.getMethod("charAt", int.class);
  57.                         System.out.println(methodCharAt.invoke(str1, 2));
  58.                         //System.out.println(methodCharAt.invoke(null, 2));  // 如果第一个参数为null,那么这个方法必须为static(静态方法)
  59.                         System.out.println(methodCharAt.invoke(str1, new Object[]{2}));
  60.                         
  61.                
  62.                         // 调用一个类的main方法,用普通的方式调用
  63.                         //TestArguments.main(new String[]{"11"}); // 普通的方法
  64.                         
  65.                         String startingClassName = args[0];
  66.                         
  67.                         Method mainMethod = Class.forName(startingClassName).getMethod("main", String[].class);
  68.                         
  69.                         mainMethod.invoke(null, (Object)new String[]{"111","222"}); // 这样的话,编译器会作特殊处理,编译时不反参数当作数组看待,也就不会数组打散成若干个参数了
  70.         
  71.                         int[] a1 = new int[]{1,2,3};
  72.                         int[] a2 = new int[4];
  73.                         int[][] a3 = new int[2][3];
  74.                         String[] a4 = new String[]{"a","b","c"};
  75.                         
  76.                         System.out.println(a1.getClass() == a2.getClass());
  77.                         
  78.                         System.out.println(a1.getClass() == a3.getClass());
  79.                         System.out.println(a1.getClass() == a4.getClass());
  80.                         
  81.                         System.out.println(a1.getClass().getSuperclass().getName());  // 它们的父类都是Object
  82.                         System.out.println(a4.getClass().getSuperclass().getName());
  83.                         
  84.                         Object b1 = a1;
  85.                         Object b2 = a2;
  86.                         //Object[] b5 = a1;   // 这样是错误的,因为a1是int数组, int 是基本类型, 不是Object的子类
  87.                         Object[] b3 = a3;   // a3是数组的数组,数组也是Object,所以OK
  88.                         Object[] b4 = a4;
  89.                
  90.                         System.out.println(a1);   // 这样的话,只会等到a1的hashcode,得不到想要的结果
  91.                         System.out.println(a4);
  92.                         
  93.                         System.out.println(Arrays.asList(a1));  // 这里error,jdk1.5会把数组当做一个Object对象,而不是当作若干个
  94.                         System.out.println(Arrays.asList(a4));  //OK
  95.                         
  96.                         printObject(a1);
  97.                         printObject("a");
  98.                 }
  99.                 catch (Exception e)
  100.                 {
  101.                         e.printStackTrace();
  102.                 }
  103.                 finally
  104.                 {
  105.                         
  106.                 }        
  107.                
  108.         }
  109.         
  110.         public static void printObject(Object obj)
  111.         {
  112.                 Class cls = obj.getClass();
  113.                 if (cls.isArray())
  114.                 {
  115.                         int len = Array.getLength(obj);
  116.                         for (int i = 0; i < len; ++i)
  117.                         {
  118.                                 System.out.println(Array.get(obj,i));
  119.                         }

  120.                 }
  121.                 else
  122.                 {
  123.                         System.out.println(obj);
  124.                 }
  125.         }
  126.         
  127.         
  128.         
  129.         private static void changeStringValue(Object obj)
  130.         {
  131.                 Field[] fields = obj.getClass().getFields();
  132.                
  133.                 for (Field field : fields)
  134.                 {
  135.                         if (field.getType() == String.class)
  136.                         {
  137.                                 try
  138.                                 {
  139.                                         String oldValue = (String)field.get(obj);
  140.                                         String newValue = oldValue.replace('b', 'a');
  141.                                         field.set(obj, newValue);
  142.                                        
  143.                                 } catch (Exception e) {
  144.                                         // TODO: handle exception
  145.                                 }
  146.                                 
  147.                         }
  148.                 }
  149.         }



  150. }


  151. class TestArguments
  152. {
  153.         public static void main(String[] args)
  154.         {
  155.                 for (String arg : args)
  156.                 {
  157.                         System.out.println(arg);
  158.                 }
  159.         }
  160. }





















复制代码

评分

参与人数 1技术分 +1 收起 理由
狼王 + 1 赞一个!

查看全部评分

7 个回复

倒序浏览
楼主,可以给完整的代码么?不知道你是在弄反射还是在弄代理、、、希望可以把代码弄到代码区那里,好复制,谢谢了
回复 使用道具 举报
yting_xmei1129 发表于 2013-10-7 21:27
楼主,可以给完整的代码么?不知道你是在弄反射还是在弄代理、、、希望可以把代码弄到代码区那里,好复制, ...

好了,85和84行,你看看是哪出了问题,多谢了!!
回复 使用道具 举报
运算符两边的类型不一致,a1.getClass() == a3.getClass());
a1.getClass() 得到的是Class<int[]>
a3.getClass()得到的是Class<int[][]>
这两个是不同类型的,报错时,你可以看一下他提示的错误信息。
回复 使用道具 举报
每一个具有相同维数和元素类型的数组属于同一个类型,即具有相同的Class实例对象。当然不同的类型的数组Class实例对象也不一样。
回复 使用道具 举报
记得改成以解决
回复 使用道具 举报
酱爆 高级黑马 2013-10-8 14:19:26
7#
狼王 发表于 2013-10-8 08:50
每一个具有相同维数和元素类型的数组属于同一个类型,即具有相同的Class实例对象。当然不同的类型的数组Cla ...

老师的视频上好像也是这样写的,为什么我就过不了,是哪个地方写错了?
回复 使用道具 举报
狼王 高级黑马 2013-10-8 22:04:31
8#
酱爆 发表于 2013-10-8 14:19
老师的视频上好像也是这样写的,为什么我就过不了,是哪个地方写错了? ...

把==改为equals就行了,好多人看视频都出现这个问题,至于老师为什么没出问题,我也不知道,要问高人
回复 使用道具 举报
您需要登录后才可以回帖 登录 | 加入黑马