java 反射从入门到精通

一：基本概念

• 反射：reflection

–程序可以访问、检测和修改它本身状态或行为的能力，即自描述

和自控制。

–可以在运行时加载、探知和使用编译期间完全未知的类。

–给Java插上动态语言特性的翅膀，弥补强类型语言的不足。

–java.lang.reflect包，在Java 2时代就有，在Java 5得到完善

 

• 反射：reflection

–在运行中分析类的能力

–在运行中查看和操作对象

• 反射构建出无法直接访问的类

• set或者get到无法访问的成员变量

• 调用不可访问的方法

–实现通用的数组操作代码

–类似函数指针的功能

 

二：关键类：

• Class：类型标识

–JVM为每个对象都保留其类型标识信息(Runtime Type

Identification)

–三种获取方式

        String s="Are you OK";

        Class c1=s.getClass();
        System.out.println(c1.getName());

        Class c2=Class.forName("java.lang.String");
        System.out.println(c2.getName());

        Class c3=String.class;
        System.out.println(c3.getName());

 

• Class：类型标识

 

– 成员变量、方法、构造函数、修饰符、包、父类、父接口……

 

 

Field

class Person{
    public String name;

    public Person(String name){
        this.name=name;
    }
}
public class Student extends Person {
    private int age;
    public int hobby_count=2;
    public Student(String name,int age) {
        super(name);
        this.age=age;
    }

    public static void main(String[] args) throws IllegalAccessException {
        Student stu1=new Student("Lucy",20);
        Class c=stu1.getClass();
        Field[]fields=c.getDeclaredFields(); //获取本类声明的字段 age和hobby_count
        Field[]fields1=c.getFields();//获取本类和父类的所有public字段

        for (Field f:fields){
            System.out.println(f.getName()+":"+f.get(stu1));//age:20 hobby_count:2
        }

    }
}

Method

class B{
   public void f1(){
       System.out.println("Hello from f1");
   }
    private void f2(String arg){
        System.out.println("Hello from f2");
    }

    public static void main(String[] args) throws InvocationTargetException, IllegalAccessException {
        B obj=new B();
        Class c=obj.getClass();
        Method[]methods=c.getDeclaredMethods();
        for (Method m:methods){
            if("f1".equals(m.getName())){
                m.invoke(obj,null);
            }
        }

        Method[]m2=c.getDeclaredMethods();//获取声明方法
        for (Method m:m2){
            m.setAccessible(true);//将private方法暂时设置成可访问的
            if("f2".equals(m.getName())){
                m.invoke(obj,"aaa");
            }
        }
    }
}

 

Constructor

class C{
 private int num;
 public C(){}
 public C(int num){
     this.num=num;
 }
public void printNum(){
    System.out.println(num);
}
    public static void main(String[] args) throws IllegalAccessException, InvocationTargetException, InstantiationException {
        C obj=new C();
        Class c=obj.getClass();
        Constructor[]constructors=c.getConstructors();
        for (Constructor con:constructors){

            if(con.getParameterCount()>0){//获取构造器参数
             C c1= (C) con.newInstance(100);
             c1.printNum();
            }
            else {
                C c2= (C) con.newInstance();
                c2.printNum();
            }
        }
    }
}

 

父类/父接口

class Person{ }
public class Student extends Person implements Cloneable,Runnable, Serializable {
   protected Object clone() throws CloneNotSupportedException {
       return super.clone();
   }
public void run(){
}
    public static void main(String[] args) {
        Student obj=new Student();
        Class s=obj.getClass();
        Class p=s.getSuperclass();
        System.out.println(p.getName()+"\n");
        Class[]interfaces=s.getInterfaces();
        for (Class i:interfaces){
            System.out.println(i.getName());
        }
    }
}