day01 ，Java 基础加强（反射）

public class Person1 { public void run(){ System.out.println("Person run method"); } }   

 

public class Test1 { public static void main(String[] args) throws ClassNotFoundException{ Class clazz1 = Person1.class; Class clazz2 = Class.forName("cn.ls.person.Person"); Class clazz3 = new Person1().getClass(); if(clazz1==clazz2 && clazz2==clazz3){ System.out.println("同一个字节码对象"); } } }

 

为什么是同一个对象呢？

看下图：这里的Class对象就是字节码对象。文件系统就是硬盘上的数据。三个String对象，用的是一个字节码对象，所以class对象是同一个对象，==比较的是地址。是同一个对象。一个String的class对象可以产生多个String对象。Class指向的两个圆形就是产生的两个String对象。

 

 

 

 

2  .

public class Person2 { public Person2(){ System.out.println("Person2()"); } public Person2(String str){ } public Person2(String str , int num){ System.out.println("Person2(String str,int num),str : " + str + " num : " + num); } public Person2(String[] str){ System.out.println("Person2(String[] str), str[0] = " + str[0] + " str[1] " + str[1]); } public void run(){ System.out.println("Person2 run method"); } }

 

 

import java.lang.reflect.Constructor; import java.lang.reflect.InvocationTargetException; import org.junit.Test; import cn.ls.person.Person2; public class Test2 { @Test public void test1() throws SecurityException, NoSuchMethodException, IllegalArgumentException, InstantiationException, IllegalAccessException, InvocationTargetException{ Class clazz = Person2.class; Constructor c = clazz.getConstructor(null); Person2 person2 = (Person2) c.newInstance(null); person2.run(); } @Test public void test2() throws SecurityException, NoSuchMethodException, IllegalArgumentException, InstantiationException, IllegalAccessException, InvocationTargetException{ Class clazz = Person2.class; Constructor c = clazz.getConstructor(String.class,int.class); Person2 p2 = (Person2) c.newInstance("haha",23); p2.run(); } @Test public void test3() throws SecurityException, NoSuchMethodException, IllegalArgumentException, InstantiationException, IllegalAccessException, InvocationTargetException{ Person2 p = new Person2(); Class clazz = Person2.class; Constructor c = clazz.getConstructor(String[].class); //下面 1 处会报异常，在jdk 1.4里的方法newInstance(object[])里面接收的是一个数组， //来匹配构造函数根据数组里传进去的元素，依次在Person2构造函数里找Person2(object[0],object[1]) //这里用的jdk6，(newInstance(Object ...)用的是可变参数)，1.6要兼容1.4的版本，如果这里传数组的话，会恢复到1.4版本，去找构造函数参数 //带两个String类型的构造函数来new对象。结果找不到。因为我没有定义这样的函数，所以出异常。 //不传数组的话，就按照可变参数往里面装 //在 2 处解决了这个问题，直接传给他一个object数组对象，这个object数组里又装了一个数组，然后他去找object数组里面的第一个元素，第一个元素是数组， //他就去找和数组里面匹配的类型。 //3 处也解决了这个问题。直接转换成一个对象，他就不会按照1.4的版本来了，而是按照可变参数的方式。把对象装进去。其实装的是一个数组 //然后自己再找。有没数组类型的。 //---1---//Person2 p2 = (Person2) c.newInstance(new String[]{"55","66"}); //---2---Person2 p2 = (Person2) c.newInstance(new Object[]{new String[]{"55","66"}}); //---3--- Person2 p2 = (Person2) c.newInstance((Object)new String[]{"55","66"}); p2.run(); } }

 

3.

 

import java.util.List; public class Person3 { public void eat(){ System.out.println("eat method"); } public void drink(String str,int i){ System.out.println("drink method str : " + str + " int : " + i); } public void play(List list){ System.out.println("play method " + list.get(0)); } private void privateMethod(){ System.out.println("private method "); } }

 

public class Test3 { @Test public void test1() throws SecurityException, NoSuchMethodException, IllegalArgumentException, IllegalAccessException, InvocationTargetException{ Class clazz = Person3.class; //getMethod第一个参数是方法名字，第二个参数是方法的参数类型。 //参数类型是个可变参数 Method m = clazz.getMethod("eat", null); m.invoke(new Person3(), null); } @Test public void test2() throws SecurityException, NoSuchMethodException, IllegalArgumentException, IllegalAccessException, InvocationTargetException{ Class clazz = Person3.class; Method m = clazz.getMethod("drink", String.class,int.class); m.invoke(new Person3(), "test2,string " ,123); } @Test public void test3() throws SecurityException, NoSuchMethodException, IllegalArgumentException, IllegalAccessException, InvocationTargetException{ Class clazz = Person3.class; Method m = clazz.getMethod("play", List.class); List list = new ArrayList(); list.add("haha"); m.invoke(new Person3(), list); } //暴力反射，就是反射私有的。 @Test public void test4() throws SecurityException, NoSuchMethodException, IllegalArgumentException, IllegalAccessException, InvocationTargetException{ Class clazz = Person3.class; //暴力反射这里不是用的getMethod(),而是用的getDeclaredMethod() Method m = clazz.getDeclaredMethod("privateMethod", null); //私有的方法要设置访问权限。才可以反射。 m.setAccessible(true); m.invoke(new Person3(), null); } }

 

4.

public class Person4 { public String name = "flx"; private int age; private List list; private String[] s; public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public List getList() { return list; } public void setList(List list) { this.list = list; } public String[] getS() { return s; } public void setS(String[] s) { this.s = s; } }

 

public class Test4 { /* * public String name = "flx"; private int age; private List list; private String[] s; */ @Test public void test1() throws SecurityException, NoSuchFieldException, IllegalArgumentException, IllegalAccessException{ Class clazz = Person4.class; Field f = clazz.getField("name"); String str = (String) f.get(new Person4()); System.out.println(str); } @Test public void test2() throws SecurityException, NoSuchFieldException, IllegalArgumentException, IllegalAccessException{ Class clazz = Person4.class; Person4 p = new Person4(); Field f = clazz.getDeclaredField("age"); f.setAccessible(true); f.set(p, 23); int i = (Integer) f.get(p); System.out.println(i); System.out.println(p.getAge()); } @Test public void test3() throws SecurityException, NoSuchFieldException, IllegalArgumentException, IllegalAccessException{ Class clazz = Person4.class; Person4 p = new Person4(); Field f = clazz.getDeclaredField("list"); List list = new ArrayList(); list.add("list haha"); f.setAccessible(true); p.setList(list); List list2 = (List) f.get(p); System.out.println(list2); } @Test public void test4() throws SecurityException, NoSuchFieldException, IllegalArgumentException, IllegalAccessException{ Class clazz = Person4.class; Person4 p = new Person4(); Field f = clazz.getDeclaredField("s"); f.setAccessible(true); f.set(p, new String[]{"haha","yeye"}); for(String temp : p.getS()){ System.out.println(temp); } } }

 

5.

public class Person5 { public static void main(String[] args) { System.out.println(args.length); } }

 

public class Test5 { public static void main(String[] args) throws SecurityException, NoSuchMethodException, IllegalArgumentException, IllegalAccessException, InvocationTargetException { Class clazz = Person5.class; Method m = clazz.getMethod("main", String[].class); //这里的invoke方法，后面一个参数也是接收可变参数。 //在传数组的时候要注意，这是1.4-5.0过渡兼容的问题。 //由于静态方法不需要传递任何对象，所以第一个参数设置为空，这里传递个对象也不会错的。 m.invoke(null, (Object)new String[]{"1","2"}); } }

 

6.通过类名字就能产生类的对象。

public class Person6 { // public Person6(String s ){ // // } public void run(){ System.out.println("oooo"); } }

 

public class Test6 { @Test public void test1() throws SecurityException, NoSuchMethodException, IllegalArgumentException, InstantiationException, IllegalAccessException, InvocationTargetException{ Class clazz = Person6.class; //---1---- Constructor c = clazz.getConstructor(null); Person6 p = (Person6) c.newInstance(null); p.run(); } @Test public void test2() throws SecurityException, NoSuchMethodException, IllegalArgumentException, InstantiationException, IllegalAccessException, InvocationTargetException{ Class clazz = Person6.class; //---2---,这里的一句内部就是test1中的1处的那两句。所以这里要求Person6里必须要有个无参的构造函数。 //假如把Person6里的有参构造函数注释拿掉，test1和test2都会报错。因为没有无参构造函数 Person6 p = (Person6) clazz.newInstance(); p.run(); } }