Java-反射机制

1.反射

   反射库(Reflection Library)提供一个丰富的工具集,以便编写能够动态操作Java代码的程序。这项功能被

   大量的应用在JavaBeans中,它是Java组件的体系结构。

   能够分析类能力的程序称为反射(Reflection),即可以将一个类(或基本数据类型),类成员当成一个对象来操作。

   它是运行时检测和修改某个对象的结构及其行为,与内省(introspection)不同。内省是反射的一个子集。

   反射:用于运行检测修改某个对象结构及其行为

   内省:用于运行时检测某个对象的类型及其包含的属性

   注意:这里是指运行时期,即如果编译时期不可以做的事情,我在运行时期使用反射就可以做了,如向定义了ArrayList <String>的集合里,运用反射加入int型数据

   内省实例: 对象名  instanceof  类名/接口名;//检测某个对象是否属于某个类或接口

   反射实例:Class.forName()方法可以获取某个类。

2.Class类

   一个Class对象实际上表示的是一个类型,这个类型不一定是一种类,因为它也可以表示基本数据类型。

   它可以将Java里的所有东西(类,接口,数组,基本数据类型,void)当成一个对象来对它的属性进行访问。

3.反射包(java.lang.reflect)下的Constructor类,Field类(成员变量),Method类(成员方法)

总结:

      1,创建Class实例对象的三种方法:

           a,Class<?> c=Class.forName(String name);

           b,Class<?> c=p.getClass();//对象名.getClass()

           c,Class<?> c=Person.Class ;//类名.Class;

      2,获取构造方法(Constructor),成员变量(Field),成员方法(Method),接口(interface)

          Class类: getDeclaredXxxx();// 获取本类中的所有Xxxx,不包括继承父类中xxx

                        getXxxx();//获取本类中的public权限的Xxxx。

package hq.com.ClassDemo;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class ClassDemo {

    /**
     * class类的演示
     */
    public static void main(String[] args) throws Exception {
        // TODO Auto-generated method stub
        Demo1();
        System.out.println("---------------------");
        Demo2();
        System.out.println("---------------------");
        Demo3();
        System.out.println("---------------------");
        Demo4();
        System.out.println("---------------------");
        Demo5();
        System.out.println("---------------------");
        Demo6();
        System.out.println("---------------------");
        Demo7();
        System.out.println("---------------------");
        Demo8();
    }
    //1.任何所有东西都是Class类的实例对象
    //创建Class实例的三种方法,Class.forName(),类名.class,对象名.getClass().
    public static void Demo1() throws ClassNotFoundException
    {
        Class<?> c1=null;
        Class<?> c2=null;
        Class<?> c3=null;
        //1,Class.forName()方法,推荐
        c1=Class.forName("hq.com.ClassDemo.Person");
        System.out.println("Demo1(写法1:forName()):类名="+c1.getName());
        //2,类名.class。在java中,每个class都有一个相应的Class对象,当编写好一个类,
                     // 编译完成后,在生成的.class文件中,就产生一个class对象
        c2=Person.class;
        System.out.println("Demo1(写法2:类名.class):类名="+c2.getName());
        //3,object类的getClass()方法
        Person p=new Person();
        c3=p.getClass();
        System.out.println("Demo2(写法3:getClass()):类名="+c3.getName());
    }
    // 2,Object的getClass()方法,Class的getName(),getPackage().
    // 演示反射机制获取类的包名和类名
    public static void Demo2() {
        Person p = new Person("hq", 22);
        System.out.println("person的类名:" + p.getClass().getName());
        System.out.println("person的包名:" + p.getClass().getPackage().getName());
    }
   //3,class的newInstance()方法
   //  通过反射,用class来创建类对象(这是反射的意义所在)
    public static void Demo3() throws  Exception
    {
        Class c=Class.forName("hq.com.ClassDemo.Person");
        Person p= (Person) c.newInstance();//要强转,默认是Object类
        p.setName("hq");
        System.out.println("Demo3(class的newInstance()方法):name="+p.getName());
    }
    //4,class的getConstructors();以数组形式返回该类的所有公共构造方法
    //   java.lang.reflect.Constructor;构造方法类
    public static void Demo4() throws  Exception
    {
        //用构造方法类创建该类的实例对象。
        //注意必须按顺序获取Constructor,即ct[0]在ct[1]之前,不能反过来
        Class   c = null;
        Person p1 = null;
        Person p2 = null;
                c = Class.forName("hq.com.ClassDemo.Person");
        Constructor<?> [] ct=c.getConstructors();
        p1=(Person) ct[0].newInstance();
        p1.setName("hh");
        p2=(Person) ct[1].newInstance("hq",22);
        System.out.println("Demo4(getConstructors()构造方法类创建实例对象):p1:name="+p1.getName());
        System.out.println("Demo4(getConstructors()构造方法类创建实例对象):p2:name="+p2.getName());
    }

    //5,class:  getDeclaredField(String name);获取该类的成员变量
    //  Field类:操作类对象的成员变量,set,get方法
    public static void Demo5() throws Exception 
    {
       //class的getDeclaredField(String name)方法获取类中的某个成员变量
       //Field类的set(Object obj,Object value),修改该字段上某个对象对应的值
        Class  c=Class.forName("hq.com.ClassDemo.Person");
        Person p=(Person)c.newInstance();
        Field f=c.getDeclaredField("age");
        f.setAccessible(true);
        f.set(p, 11);
        System.out.println("Demo5(Field的set(对象,值)):person:age="+p.getAge());
        System.out.println("Field.get():"+f.get(p));
        
    }
    //6,获取该类的父类信息,成员方法,接口,成员变量(字段)
    public static void Demo6() throws  Exception
    {   
        //注意:getDeclaredFields()和getFields()区别是,
        //前者是所有声明的字段,后者是仅为public权限的字段
        //注意:两者获取的字段均为该类内部中定义的,不包括继承父类的字段
        Class<?> c=Class.forName("hq.com.ClassDemo.SuperMan");
        Class<?> superClass=c.getSuperclass();
        System.out.println("Demo6:superman的父类是:"+superClass.getName());
        //获取类中所有字段
        Field [] fs=c.getDeclaredFields();
        int i=0;
        for(Field f:fs)
        {   
          i++;
         System.out.println("superman的第"+i+"个成员:"+f.getName());
        }
        //获取类中所有方法
        Method [] ms=c.getDeclaredMethods();
        for(Method m:ms)
        {    
             i++;
             System.out.println("superman的第"+i+"个成员方法:"+m.getName());
         }
        //获取类实现的接口
        Class<?>[] is=c.getInterfaces();
        for(Class<?> j:is)
        {
             System.out.println("superman的第"+i+"个接口:"+j.getName());
        }
    }
    //7,调用类的方法,Method类的invoke()方法
    public static void Demo7() throws Exception
    {
        Class<?> c=Class.forName("hq.com.ClassDemo.SuperMan");
        //调用类中的无参数方法
        Method  m1=c.getMethod("fly");
        System.out.print("Demo7:superman中的无参数方法fly():");
        m1.invoke(c.newInstance());
        //调用类中的参数方法,先取出该方法,再放入参数(实例,方法参数)
        Method m2=c.getMethod("walk",int.class);
        System.out.print("Demo7:superman中的有参数方法walk():");
        m2.invoke(c.newInstance(),4);
    }
    /** 
     * Demo8: 通过Java反射机制得到类加载器信息 
     *  
     * 在java中有三种类类加载器。[这段资料网上截取] 
 
        1)Bootstrap ClassLoader 此加载器采用c++编写,一般开发中很少见。 
 
        2)Extension ClassLoader 用来进行扩展类的加载,一般对应的是jre\lib\ext目录中的类 
 
        3)AppClassLoader 加载classpath指定的类,是最常用的加载器。同时也是java中默认的加载器。   
     */ 
    public static void Demo8() throws ClassNotFoundException  
    {  
        Class<?> class1 = null;  
        class1 = Class.forName("hq.com.ClassDemo.SuperMan");  
        String nameString = class1.getClassLoader().getClass().getName();  
          
        System.out.println("Demo8: 类加载器类名: " + nameString);  
    }  
}
class SuperMan extends Person implements ActionInterface 
{
    
    private boolean BlueBriefs;
    public boolean isBuleBriefs()
    {
        return this.BlueBriefs;
    }
    public void setBuleBriefs(boolean BlueBriefs)
    {
        this.BlueBriefs=BlueBriefs;
    }
    public void fly()
    {
        System.out.println("超人会飞哦~~");
    }
    @Override
    public void walk(int m) {
        // TODO Auto-generated method stub
        System.out.println("超人也会走耶~~走了"+m+"米后走不动了");
    }
    
}
interface ActionInterface
{
    public void walk(int m);
}
class Person {
    private int age;
    private String name;

    public Person() {

    }

    public Person(String name, int age) {
        this.age = age;
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getAge() {
        return this.age;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return this.name;
    }
}

 

posted @ 2015-02-05 10:01  beyondbycyx  阅读(166)  评论(0编辑  收藏  举报