反射

来源：互联网发布：淘宝网店提升信誉编辑：程序博客网时间：2024/06/10 21:34

1.反射？

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

2.如何得到类对象
<1>类名.class

<2>对象.getClass()

<3>Class.forName("全限定名");

<4>类加载的loadClass("全限定名")；

<5>子类.class.getSuperClass();

<6>包装类.class

3.根据类得到类名(全限定名)

c.getName()------------>全限定名

c.getSimpleName() ---->类名

c.getPackage()---------->包名

4.根据类得到类的属性
   c.getField("field属性名");
   属性名：f.getName()
   属性修饰符：f.getModifiers()
   属性的数据类型：f.getType().getName()
   给属性设值：f.set()
   得到属性的值：f.get()

   得到私有的属性：f.getDeclaredField("属性名");

   得到所有的声明的属性
   c.getDeclaredFields()

5.根据类得到类的方法

c.getMethod()
c.getDeclaredMethod();

6.根据类得到类的构造方法
7.根据类得到类的实现接口列表

代码如下：

package com.zking.test;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

import org.junit.Test;

import com.zking.entity.Person;

public class TestRe {

   /**
   * 获取实现该类的所有接口及父类
   */
   @Test
   public void test6(){
       Class clazz=Person.class;
       System.out.println(clazz.getSuperclass().getSimpleName());
       //实现的接口
       Class clazzInterface[]=clazz.getInterfaces();
       for (Class c : clazzInterface) {
           System.out.println(c.getSimpleName());
       }
   }





   /**
   * 获取该类所有的构造方法，并执行
   */
   @Test
   public void test5(){
       Class clazz=Person.class;
       Constructor constructor[]=clazz.getDeclaredConstructors();
       for (Constructor c : constructor) {
           System.out.println(c.getModifiers());
           Class clazzType[]=c.getParameterTypes();
           for (Class cc : clazzType) {
               System.out.println(" "+cc.getSimpleName());
           }
       }
       //调用构造方法（使用构造方法进行实例化对象）
       try {
           //clazz.newInstance();//调用无参构造
           //调用有参构造
           Constructor constru=clazz.getDeclaredConstructor(Integer.class,String.class,Integer.class);
           constru.newInstance(1,"123",2);
       } catch (Exception e) {
           e.printStackTrace();
       }
   }



   /**
   * 根据类对象获取类的所有的方法
   */
   @Test
   public void test4(){
       //获取所有的方法
       Class clazz=Person.class;
       Method methods[]=clazz.getDeclaredMethods();
       System.out.println(methods.length);
       for (Method method : methods) {
           //获取每个方法的名字
           System.out.println(method.getName());

           //每个方法的返回值类型
           System.out.println(" "+method.getReturnType().getName());

           //每个方法的修饰符
           System.out.println(" "+method.getModifiers());

           //获取每个方法的参数列表
           Class[] classType=method.getParameterTypes();
           for (Class c : classType) {
               System.out.println("   "+c.getSimpleName());
           }
       }


       //调用方法(无参数)
       try {
           Person person=new Person();
           Method method=clazz.getDeclaredMethod("sleep", String.class,String.class);
           //设置可访问
           method.setAccessible(true);
           //执行方法
           method.invoke(person, "雷一鸣和民民","静静");
       } catch (Exception e) {
           e.printStackTrace();
       }
   }
   /**
   * 根据类对象获取类的属性
   */
   @Test
   public void test3(){
       try {

           //之前
           Person person=new Person();
           //person.setPid(1);
           Person person2=new Person();
           //person2.setPid(100);
           Class clazz=Person.class;
           Field[] fields=clazz.getFields();//只能获取public修饰的属性
           Field[] fields2=clazz.getDeclaredFields();//获取所有的属性（包括私有）
           for (Field field : fields2) {
               //获取所有属性的属性名
               System.out.println(field.getName());
           }

           System.out.println(fields2.length);
           //获取单个属性（获取的public）
           Field field=clazz.getField("pid");
           //给属性设值
           field.setInt(person, 100);
           //获取属性的值
           System.out.println(field.getInt(person));

           //获取单个属性(修饰符为private)
           //Field fieldPname=clazz.getField("pname");
           Field fieldPname=clazz.getDeclaredField("color");
           System.out.println(fieldPname);

           System.out.println("psex的数据类型为："+fieldPname.getType().getSimpleName());
           //private 2
           //public 1
           //protected 4
           //默认 0
           //static 8
           //final 16

           System.out.println(Modifier.isPublic(25));

           System.out.println("color的修饰符为："+fieldPname.getModifiers());

           //设置可以访问
           fieldPname.setAccessible(true);

           //给私有的属性设值
           fieldPname.set(person, "落魄灰");

           //获取私有属性的值
           System.out.println(fieldPname.get(person));

       } catch (Exception e) {
           e.printStackTrace();
       }
   }
   /**
   * 根据类对象获取类名(全限定名包名)
   */
   @Test
   public void test2(){
       Class clazz=Person.class;
       //获取全限定名
       System.out.println(clazz.getName());
       //获取类名(不包括包名)
       System.out.println(clazz.getSimpleName());
       //获取包名
       System.out.println(clazz.getPackage().getName());
   }

   /**
   * 获取类对象
   */
   @Test
   public void test1() {
       try {
           // 1.实体类.class
           // Class clazz=Person.class;
           // 2.对象.getClass
           // Person person=new Person();
           // Class clazz=person.getClass();
           // 3.Class.forName()
           //Class clazz = Class.forName("com.zking.entity.Person");
           //4.通过类加载的loadClass
//           ClassLoader classLoader=Person.class.getClassLoader();
//           Class clazz =classLoader.loadClass("com.zking.entity.Person");
           //5.通过子类.class.getSuperClass()
//           Class clazz =Son.class.getSuperclass();
//           System.out.println(clazz);

//           [6].获取包装类的类对象
           Class clazz=Integer.class;
           System.out.println(clazz);

       } catch (Exception e) {
           e.printStackTrace();
       }

   }
}

阅读全文

0 0