java反射机制

java.lang.Class 类是Java中的反射中心。
Class类的一个对象表示运行时程序中的一个类。

1、所以实例化Class类的方式有点特殊，有三种方式获取类的Class对象的引用:
- 使用类文字
- 使用Object类的getClass()方法
- 使用Class类的forName()方法

    //getClass()
                String str="hello";
                Class<?> cls=str.getClass();
                System.out.println(cls);
    //包.类.class     
                Class<?> cls1=java.lang.String.class;
                System.out.println(cls1);
    //类不确定的情况下实例化Class，forName()更具灵活性
            Class<?> cls2=Class.forName("java.lang.String");
            System.out.println(cls2);

运行结果

class java.lang.String
class java.lang.String
class java.lang.String

2、反射实例化Class对象
注：反射存在很多异常，此处有省略一些异常处理
- 无参数实例化

class MClass {
      public MClass() {
         System.out.println("调用类初始化对象");
      }
}
public class Test{
      public static void main(String[] args) throws InstantiationException {
        Class<?> c = null;
        try {
            c = Class.forName("fanshe.MClass");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }           
        try {
      //将构造好的对象向下转型为MClass类,newInstance()方法会抛异常
          MClass p = (MClass) c.newInstance();
          System.out.println(p);
        } catch (InstantiationException | IllegalAccessException e) {
          System.out.println(e.getMessage());
        }
      }
}

• 有参数实例化

class MyClass {
      public MyClass(int i, String s) {
        System.out.println("对象初始化");
        System.out.println("参数   "+i+" "+s);
      }
}
public class Test {
      public static void main(String[] args) {
            Class<?> Cls =null;
            try {
                Cls = Class.forName("fanshe.MyClass");
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
            try {
               //获得Class类对象的有参构造方法,括号里面参数的写法是：类型.class
              Constructor<MyClass> cons = (Constructor<MyClass>) Cls.getConstructor(int.class,String.class);
              //用此构造方法构造一个新的MyClass对象给myCls
              MyClass myCls = cons.newInstance(1, "abc");
              System.out.println(myCls);
            } catch (NoSuchMethodException | SecurityException | InstantiationException
                | IllegalAccessException | IllegalArgumentException
                | InvocationTargetException e) {
              System.out.println(e.getMessage());
            }
     }
}

3、利用反射机制获取类结构

• 获取类的构造方法

class Persons{
    private int n;
    public Persons(){       
    }
    public Persons(int n){
        this.n=n;
    }
}
public class Test{
    public static void main(String[] args) {
        Class<?> c2 = null;
        try {
            c2 = Class.forName("fanshe.Persons");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        //这里的getConstructors()方法返回的是一个Constructor数组
        Constructor<?>[] cons = c2.getConstructors();
        //打印的方式你可以自己写，为了方便我用Arrays.toString()，凑合着看
        System.out.println(Arrays.toString(cons));
    }
}

• 获取类实现的接口

public interface Student {
   public void study();
}
//-----------------------------
class Persons implements Student{   
    public void study() {
        System.out.println("学习使我快乐");
    }
}

public class Test{
    public static void main(String[] args) {
        Class<?> cls = null;
        try {
            cls = Class.forName("fanshe.Persons");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        Class<?>[] in = cls.getInterfaces();
        System.out.println(Arrays.toString(in));

    }
}

运行结果：
[interface fanshe.Student]

• 获取父类：java中是单继承，父类只有一个

class Persons{
    public void study(){        
    }
}
class Student extends Persons { 
    public void study() {
        System.out.println("学习使我快乐");
    }
}

public class Test{
    public static void main(String[] args) {
        Class<?> cls = null;
        try {
            cls = Class.forName("fanshe.Student");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        Class<?> su = cls.getSuperclass();
        System.out.println(su);
    }
}

运行结果

class fanshe.Persons

• 获取类的全部方法

//获取类的全部方法
class Persons{
    public void music(){
        System.out.println("Me and You");
    }
    public void dance(){
        System.out.println("forever");
    }
}
public class Test{
    public static void main(String[] args) {
        Class<?> cls = null;
        try {
            cls = Class.forName("fanshe.Persons");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        Method[] m = cls.getMethods();
        for (int i = 0; i < m.length; i++) {
            System.out.println(m[i]);
        }
    }
}

结果

public void fanshe.Persons.music()
public void fanshe.Persons.dance()
public final void java.lang.Object.wait() throws java.lang.InterruptedException
public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException
......

• 取得本类的全部属性

class Persons{
    private int num;
    private String name;
}
public class Test{
    public static void main(String[] args) {
        Class<?> cls = null;
        try {
            cls = Class.forName("fanshe.Persons");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        //取得本类的全部属性
        Field[] f = cls.getDeclaredFields();
        for (int i = 0; i < f.length; i++) {
            System.out.println(f[i]);
        }
    }
}

获取属性对应的值

class Person {  
    public String name;
    private int age;    
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}
public class Refect {
    public static void main(String[] args) throws ClassNotFoundException,...{
            Person  p= new Person("link",20);
            Class<?> cls= p.getClass();

            //获取公共属性的值,get(p)表明要获取是哪个对象的值
            Field f2 = cls.getField("name");
            String nam = (String) f2.get(p);
            System.out.println("姓名： " + nam);

            //setAccessible()方法可以设置是否访问和修改私有属性,age是私有属性设为true
            //获取私有属性的值
            Field f3 = cls.getDeclaredField("age");
            f3.setAccessible(true);
            int age = (int) f3.get(p);
            System.out.println("年龄： " + age);
    }
}

结果

姓名： link
年龄： 20

• 反射调用方法

class Pers{
    public void num(int n) {
        System.out.println(n);
    }
    public static void use(String str) {
        System.out.println(str);
    }
}
public class Fs {
     public static void main(String[] args) throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
         Pers p = new Pers();
         Class<?> c = p.getClass();

         //getMethod()方法需要传入方法名，和参数类型
         Method m1 = c.getMethod("num", int.class);
         //invoke()表示调用的意思，需要传入对象和参数
         m1.invoke(p, 10);

         Method m2 = c.getMethod("use", String.class);
         //这里的null表示不由对象调用，也就是静态方法
         m2.invoke(null, "工具");
    }
}