Java的反射机制(学习笔记）

Java 反射机制是在动态运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；这种动态获取信息以及动态调用对象方法的功能称为 Java 语言的反射机制。简单来说，反射机制指的是程序在运行时能够获取自身的信息。在 Java 中，只要给定类的名字，就可以通过反射机制来获得类的所有信息。

通过Class.forname(String classpath ),classpath为类路径(包.类),然后再用所有类的父类Object类以多态的方式调用newInstance()方法，然后返回Object。

如JAVA反射工厂模式，在动态运行的过程中实例化对象：

package com3_7_javatest;


import java.util.Scanner;

interface Letter{
     public void show();
 }
 class A implements  Letter{

     public void show(){
         System.out.println("这是A类");
     }
 }
class  B implements  Letter{

     public void  show(){
         System.out.println("这是B类");
     }
}
class C implements  Letter{
     public void show(){
         System.out.println("这是C类");
     }
}




public class relect {
    public static void main(String[] args) {

        Scanner in=new Scanner(System.in);
        System.out.println("输入新创建对象的类名");//对象必定归属于某一类
        try {
            Class class1 = Class.forName("com3_7_javatest."+in.nextLine());
            Object myobject = class1.newInstance();
            Letter letter= (Letter) myobject;
         letter.show();
        }
        catch (Exception e){
            System.out.println("异常！");
        }



    }
}

动态编译最大限度地发挥了JAVA的灵活性，体现了多态的应用，降低了类之间的耦合性。一句话，反射机制的优点就是可以实现动态创建对象和编译，在开发中更显灵活性。

如读取配置文件（.properties)，并通过反射实例化对象反编译对象的方法

package com3_14;


import java.io.FileInputStream;
import java.lang.reflect.Method;
import java.util.*;

public class TestReflect {

    public static void main(String[] args) {



        try{
            Properties pps = new Properties();
                     pps.load(new FileInputStream("Q:\\codes_sources\\java源\\yzh3\\src\\com3_14\\config.properties"));
            //这个路径是绝对路径
                  Enumeration enum1 = pps.propertyNames();//得到配置文件的名字

            Class class1 = Class.forName(pps.getProperty("classname"));
                    //通过读配置文件键的形式获取值

                        Object object = class1.newInstance();
                       String arr= pps.getProperty("args");

                         String[] as = arr.split(",");


                     Method method=class1.getDeclaredMethod(pps.getProperty("method"),int.class,int.class,String.class);
                     //getDeclaredMethod(方法名，参数类型）//没有参数 参数类型填空
                    System.out.println("测试");
                    Object s= method.invoke(object, Integer.parseInt(as[0]), Integer.parseInt(as[1]),as[2]);//注：方法返回值是void 结果是null


           



                    } catch (Exception e) {
                        System.out.println("异常");
                    }


    }
}

Point 类，反编译它的move方法：

package com3_14;

 


public class Point  {
    public int x;
    public int y;
    private  String name  ;
    public  Point(){

    }

    public Point (String name){
        this.name=name;
    }

    public Point (int x){
        this.x=x;
    }
    public Point(int x,int y){
        this.x=x;
        this.y=y;

    }
    public  Point(int x,int y,String name){
        this.x=x;
        this.y=y;
        this.name=name;
    }
    public  void move(int dx,int dy,String nameString ){


        x=x+dx;
        y=y+dy;
        name=nameString;
        System.out.println("执行move方法");
    }

    public int getX() {
        return x;
    }

    public void setX(int x) {
        this.x = x;
    }

    public int getY() {
        return y;
    }

    public void setY(int y) {
        this.y = y;
    }

    public int hashcode(){
        final  int prime=31;
        int result=1;
        result=prime*result+x;
        result=prime*result+y;
        return result;
    }

    public  boolean equals(Object obj){
        if(this==obj)return  true;
        if(obj==null)return false;
        if(getClass()!=obj.getClass())return  false;
        Point other=(Point)obj;
        if(x!=other.x)return false;
        if(y!=other.y)return  false;
        return true;
    }
}

配置文件：

classname=com3_14.Point
method=move
args=12,24,"wuhan"
argsType=int ,int ,String

缺点：

• 反射会消耗一定的系统资源，因此，如果不需要动态地创建一个对象，那么就不需要用反射；
• 反射调用方法时可以忽略权限检查，获取这个类的私有方法和属性，因此可能会破坏类的封装性而导致安全问题。