Java学习笔记——反射

反射就是把Java类中的各种成分映射成相应的java类。

Class类-->java程序中的各个java类属于同一事物，描述这类事物的Java类名就是Class。

Class.forName的作用：返回类的字节码，返回的方式有两种，一种是这个类曾被加载过，则直接从JVM中返回字节码，另一种是JVM中没用这个类的字节码，得用类加载器先将字节码加载到JVM中，然后返回字节码。

得到类的字节码的三种方式
1.类名.class
2.对象.getClass();
3.Class.forName（"完整类名"）;例如： Class.forName("java.lang.String");(多用于反射)

public class ReflectTest {

    public static void main(String[] args) throws Exception{
        
        String str = "abc";
        Class cls1 = str.getClass();
        Class cls2 = String.class;
        Class cls3 = Class.forName("java.lang.String");
        
        System.out.println(cls1==cls2);//true
        System.out.println(cls1==cls3);//true
        
        //判断是否是基本类型
        System.out.println(cls1.isPrimitive());//false
        System.out.println(int.class.isPrimitive());//true
        System.out.println(int[].class.isPrimitive());//false
        
        System.out.println(int.class==Integer.class);//false
        System.out.println(int.class==Integer.TYPE);//true
        
    }

}

//用反射实现    new String(new StringBuffer("abc")
    Constructor constructor =     String.class.getConstructor(StringBuffer.class);
    String str1 = (String) constructor.newInstance(new StringBuffer("abc"));
    System.out.println(str1);//abc

成员变量的反射(Field类)

//定义一个Point类
public class Point {
    
    private int x;
    public int y;
    
    public Point(int x, int y) {
        super();
        this.x = x;
        this.y = y;
    }

}

用反射映射Point类

Point p = new Point(3,4);
Field filedY = p.getClass().getField("y");//getField只能得到可见的属性
System.out.println(filedY.get(p));//得到对象p在属性y上的具体值
   
Field filedX = p.getClass().getDeclaredField("x");//getDeclaredField可以得到私有属性
filedX.setAccessible(true);//暴力反射，将私有的设置为可访问的
System.out.println(filedX.get(p));

成员变量反射练习
public class Cat {
    
    String name = "Happy";
    String eyes = "Black";
    String eat = "beef";
    @Override
    public String toString() {
        return "Cat [name=" + name + ", eyes=" + eyes + ", eat=" + eat + "]";
    }
    
}
public class ReflectTest2 {

    public static void main(String[] args) throws Exception {
        
        Cat cat = new Cat();
        System.out.println(cat);//Cat [name=Happy, eyes=Black, eat=beef]
        ChangeCat(cat);
        System.out.println(cat);//Cat [name=Hbppy, eyes=Blbck, eat=beef]

    }

    private static void ChangeCat(Cat obj) throws Exception {
        
        Field[] fields = obj.getClass().getDeclaredFields();
        
        for(Field field:fields){
            field.setAccessible(true);
            if(field.getType()==String.class){
                String oldStr = (String) field.get(obj);
                String newStr = oldStr.replace('a', 'b');
                field.set(obj, newStr);
            }
        }
        
    }

}

成员方法反射(Method类)

public class ReflectTest2 {

    public static void main(String[] args) throws Exception {
        
        String str1 = "abc";
        Method method =  Class.forName("java.lang.String").
            getMethod("charAt", int.class);
        char ch = (char) method.invoke(str1, 1);
        System.out.println(method.invoke(str1, 1));//b
        System.out.println(method.invoke(str1, new Object[]{2}));//c

    }

}

对含有数组参数的成员方法进行反射

//定义一个含有main方法的类
class TestArguments{
    public static void main(String[] args){
        
        for(String arg : args){
            System.out.println(arg);
        }
    }
}

public class ReflectTest {

    public static void main(String[] args) throws Exception {
        
        
        /*用反射来实现调用main方法*/
        String className = args[0];
        Method mainMethod = Class.forName(className).getMethod("main", String[].class);
        mainMethod.invoke(null, (Object)new String[]{"111","222","333"});
        mainMethod.invoke(null, new Object[]{new String[]{"111","222","333"}});

       //以上两种调用等价，jdk1.5后，会将数组参数进行拆解，这样上述的一个数组参数就变成了3个参数，则会出现数组个数不匹配，
      //故应将数组强制转换成Object或将数组作为一个对象用Object数组进行封装

    }

}