java 反射机制

1.反射机制是什么：

（1）反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

（2）理解：JAVA反射（放射）机制：“程序运行时，允许改变程序结构或变量类型，这种语言称为动态语言”。从这个观点看，Perl，Python，Ruby是动态语言，C++，Java，C#不是动态语言。但是JAVA有着一个非常突出的动态相关机制：Reflection，用在Java身上指的是我们可以于运行时加载、探知、使用编译期间完全未知的classes。换句话说，Java程序可以加载一个运行时才得知名称的class，获悉其完整构造（但不包括methods定义），并生成其对象实体、或对其fields设值、或唤起其methods。

python为何称为动态语言：例：

class person

  def _init_ (self, name=None,age=None)

　　self.name=name

　　self.age=age

p=person("tgz","5")

p.sex=male

这时候就发现问题了，我们定义的类里面没有sex这个属性啊！怎么回事呢？ 这就是动态语言的魅力和坑！ 这里 实际上就是 动态给实例绑定属性！

2.反射机制的功能：

反射机制主要提供了以下功能： 

• 在运行时判断任意一个对象所属的类；

• 在运行时构造任意一个类的对象；

• 在运行时判断任意一个类所具有的成员变量和方法；

• 在运行时调用任意一个对象的方法；

• 生成动态代理。

3.反射机制获取类有三种方法：

例：

package practice1;
 6 import java.lang.Class; 9 public class tgztext {
    public static void main(String []args) throws Exception{
          Class<?> class1=null;
          Class<?> class2=null;
          Class<?> class3=null;
          class1=Class.forName("practice1.tgztext");
          class2=new tgztext().getClass();
          class3=tgztext.class;
          System.out.println(class1.getName());
          System.out.println(class2.getName());
          System.out.println(class3.getName());
    }
}

 4.获取一个对象的父类与实现接口

getSuperclass() getInterfaces()

package practice1;

import java.lang.Integer;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.Class;
import java.lang.reflect.Modifier;
import java.lang.reflect.Constructor;
public class tgztext {
    public static void main(String []args) throws Exception{
        Class <?> clazz=Class.forName("practice1.tgztext");
        Class<?>parentClass=clazz.getSuperclass();
        System.out.println("clazz的父类为:"+parentClass.getName());
        Class <?>interfaces[]=clazz.getInterfaces();
        for(int i=0;i<interfaces.length;i++)
        {
            System.out.println(interfaces[i].getName());
        }
    }
}

5.通过反射机制实例化一个类的对象

//第一种方法，实例化默认构造方法，调用set赋值        
        Class <?> clazz=null;
        clazz=Class.forName("practice1.user");
        System.out.println(clazz.getName());
        user user1=(user) clazz.newInstance();
        user1.setAge(10);
        user1.setName("qwe");
        System.out.println(user1);
        user user4=new user(10,"pdd");
        System.out.println(user4);
        //第二种方法 取得全部构造函数 用构造函数赋值
        Constructor<?> cons[]=clazz.getConstructors();
        for(int i=0;i<cons.length;i++)
        {
            Class<?> classes[]=cons[i].getParameterTypes();
            System.out.print("cons["+i+"](");
            for(int j=0;j<classes.length;j++)
            {
                if(j==classes.length-1)
                    System.out.print(classes[j].getName());
                else
                    System.out.print(classes[j].getName()+",");
            }
            System.out.println(")");
        }
        user user2=(user) cons[1].newInstance("asd");
        System.out.println(user2);

6.获取某个类的全部属性

Field[] field = clazz.getDeclaredFields();

取得实现的接口或者父类的属性

Field []fields1=clazz.getFields();

        Class<?>clazz =Class.forName("practice1.tgztext");
        //取得本类的全部属性
        Field[] fields=clazz.getDeclaredFields();
        for(int i=0;i<fields.length;i++)
        {
            //权限修饰符
            int mo=fields[i].getModifiers();
            String priv=Modifier.toString(mo);
            //属性类型
            Class<?>type=fields[i].getType();
            System.out.println(priv+" "+type.getName()+" "+fields[i].getName());
        }
        
        //实现的接口或父类属性
        Field []fields1=clazz.getFields();
        for(int i=0;i<fields1.length;i++)
        {
            //权限修饰符
            int mo=fields1[i].getModifiers();
            String priv=Modifier.toString(mo);
            //属性类型
            Class<?>type=fields1[i].getType();
            System.out.println(priv+" "+type.getName()+" "+fields1[i].getName());
        }

7.获取某个类的全部方法

Method[] method=clazz.getMethods();

8.通过反射机制调用某个类的方法

        Class<?>clazz =Class.forName("practice1.tgztext");
        Method[] method=clazz.getMethods();
        for(int i=0;i<method.length;i++)
        {
            Class<?>returnType=method[i].getReturnType();
            Class<?> param[]=method[i].getParameterTypes();
            int temp=method[i].getModifiers();
            System.out.print(Modifier.toString(temp)+" ");
            System.out.print(returnType.getName()+" ");
            System.out.print(method[i].getName());
            System.out.print("(");
            for(int j=0;j<param.length;j++)
            {
                System.out.print(param[j].getName()+" "+"args"+j);
                if(j<param.length-1)
                {
                    System.out.print(",");
                }
            }
            Class<?>exce[]=method[i].getExceptionTypes();
            if(exce.length>0)
            {
                System.out.print(")throws ");
                for(int k=0;k<exce.length;k++)
                {
                    System.out.print(exce[k].getName()+" ");
                    if(k<exce.length-1)
                    {
                        System.out.print(",");
                    }
                }
            }
            else{
                System.out.print(")");}
            System.out.println();
        }

通过反射机制调用某个类的方法

method=clazz.getMethod("reflect2", int.class,String.class);

method.invoke(clazz.newInstance(), 20,"张三");

public static void main(String []args) throws Exception{
Class<?>clazz=Class.forName("practice1.tgztext");
        Method method=clazz.getMethod("reflect1");
        method.invoke(clazz.newInstance());
        method=clazz.getMethod("reflect2", int.class,String.class);
        method.invoke(clazz.newInstance(), 20,"张三");
    }
    public void reflect1()
    {
        System.out.println("a");
    }
    public void reflect2(int age,String name)
    {
        System.out.println(age+name);
    }