java 反射机制详解及实例代码

更新时间：2016年11月02日 10:45:18 投稿：lqh

这篇文章主要介绍了java 反射机制详解及实例代码的相关资料,需要的朋友可以参考下

java 反射机制：

测试实体类

以Human为例

/**
 * Project: Day12_for_lxy
 * Created: Lulu
 * Date: 2016/8/10
 */
public class Human<T> {
  private String name;
  private int age;
  private float height;

  private static int legs = 2;
  private Map<String, String> jobs;
  private T t;

  public int say() {
    System.out.println("I'm" + name);
    return 0;
  }
  private void sleep(Human human) {
    System.out.println(name + " sleep with " + human.name);
  }
  public List<Integer> getList() {
    return new ArrayList<>();
  }
  public Human() {
  }
  private Human(String name, int age, float height) {
    this.name = name;
    this.age = age;
    this.height = height;
  }
  public String getName() {
    return name;
  }
  public void setName(String name) {
    this.name = name;
  }
  public int getAge() {
    return age;
  }
  public void setAge(int age) {
    if (age > 150 || age < 0) {
      throw new RuntimeException("age > 150 || age < 0");
    }
    this.age = age;
  }
  public float getHeight() {
    return height;
  }
  public void setHeight(float height) {
    this.height = height;
  }
  @Override
  public String toString() {
    return "Human{" +
        "name='" + name + '\'' +
        ", age=" + age +
        ", height=" + height +
        '}';
  }
}

测试获取构造方法

/**
 * Project: Day12_for_lxy
 * Created: Lulu
 * Date: 2016/8/10
 */
/*
获取构造方法
 */
public class TestConstructor {
  public static void main(String[] args) {
    //得到相应的类结构, 这是用来描述Human这个类的类
    Class<Human> humanClass = Human.class;
    try {
////      这是在知道构造方法结构的前提下
//      //获取都明确参数的构造方法, 获取的是公开的(public)
//      Constructor<Human> constructor1 = humanClass.getConstructor(String.class, Integer.TYPE, Float.TYPE);
//
//      Human h1 = constructor1.newInstance("小明", 18, 1.85f);
//      System.out.println(h1.toString());
//
//      //构造方法, 修饰符类型
//      int modifiers = constructor1.getModifiers();
//      if (Modifier.isPublic(modifiers)) {
//        System.out.println("是public");
//      }

//      ////获取都明确参数的构造方法, 获取的是声明的
//      Constructor<Human> constructor2 = humanClass.getDeclaredConstructor(String.class, Integer.TYPE, Float.TYPE);
//      //设置可以全部访问
//      constructor2.setAccessible(true);
//      //这样是可以获取到所有的构造方法, 包括私有的
//      Human human2 = constructor2.newInstance("zll", 18, 1.80f);
//      System.out.println(human2.toString());

      //不知道构造方法的类结构
      Constructor<?>[] constructors = humanClass.getDeclaredConstructors();

      for (Constructor<?> c : constructors) {
        c.setAccessible(true);
        System.out.println(c.getName());
        System.out.println("===========================");
        //参数列表
        Class<?>[] types = c.getParameterTypes();
        for (Class<?> type : types) {
          System.out.println(type.getTypeName());
        }

        //修饰符类型
        int modifiers = c.getModifiers();
        if (Modifier.isPublic(modifiers)) {
          System.out.println("是公开的");
        }else if (Modifier.isPrivate(modifiers)){
          System.out.println("是私有的");
        }
      }


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

  }
}

测试获取字段

/**
 * Project: Day12_for_lxy
 * Created: Lulu
 * Date: 2016/8/10
 */

/*
获取属性:
属性包括:( 属性名 类型 修饰符 泛型 )
父类的属性
自身的属性
 */
public class TestField {
  public static void main(String[] args) {
    Class<Human> humanClass = Human.class;
    Field[] fields = humanClass.getDeclaredFields();
    for (Field f : fields) {

      //属性名
      System.out.print(" 名字: " + f.getName() + " ");
      System.out.println();
      //类型
      System.out.print("类型 :" + f.getType() + " ");
      System.out.println();
      //修饰符
      int modifiers = f.getModifiers();
      if (Modifier.isPublic(modifiers)) {
        System.out.println("公开的");
      } else if (Modifier.isPrivate(modifiers)) {
        System.out.println("私有的");
      }
    }
    System.out.println("============================泛型==================================");
    try {
      //通过类结构获取jobs属性
      Field jobs = humanClass.getDeclaredField("jobs");
      //泛型
      ParameterizedType type = (ParameterizedType) jobs.getAnnotatedType().getType();
      Type[] types = type.getActualTypeArguments();
           for (Type type1 : types) {
        System.out.println(type1);
      }
    } catch (Exception e) {
      e.printStackTrace();
    }
    System.out.println("===================设置值, 得到值============================");

    try {
      Human<Object> human = new Human<>();
      //非静态, 你要知道给谁设置属性的值
      Field nameField = humanClass.getDeclaredField("name");
      nameField.setAccessible(true);
      nameField.set(human, "路新艺");
      System.out.println(human.getName());

      //静态
      Field legs = humanClass.getDeclaredField("legs");
      int modifiers = legs.getModifiers();
      legs.setAccessible(true);
      if (Modifier.isStatic(modifiers)) {
        System.out.println("是静态的");
      }
      legs.set(null, 4);
      System.out.println(legs.get(null));

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

测试获取方法

/**
 * Project: Day12_for_lxy
 * Created: Lulu
 * Date: 2016/8/10
 */
/*
获取方法:
方法名
修饰符
返回值类型
泛型

静态和非静态

方法的调用

 */
public class TestMethod {
  public static void main(String[] args) {

    Class<Human> humanClass = Human.class;
    //方法名
    Method[] ms = humanClass.getDeclaredMethods();
    for (Method m : ms) {
      m.setAccessible(true);
      System.out.print("方法名: " + m.getName() + "  " );
      int modifiers = m.getModifiers();

      if (Modifier.isPublic(modifiers)) {
        System.out.println("公开的");
      } else if (Modifier.isPrivate(modifiers)) {
        System.out.println("私有的");
      }
    }
    //在确定方法参数的情况下  方法名不能唯一的确定, 重载
    try {
      //普通类型
      Method sayM = humanClass.getDeclaredMethod("say");
      Class<?> returnType = sayM.getReturnType();
      System.out.println(returnType.toString());
      //泛型
      Method getListM = humanClass.getDeclaredMethod("getList");
      System.out.println(getListM.getReturnType());

      ParameterizedType type = (ParameterizedType) getListM.getAnnotatedReturnType().getType();
      System.out.println(type);
      Type[] ts = type.getActualTypeArguments();
      for (Type t : ts) {
        System.out.println(t);
      }


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

测试获取类信息

public static void main(String[] args) {
  printClassInfo(Student.class);
}

public static void printClassInfo(Class c){
    //Java中唯一的父类的类时Object
    System.out.println(c.getName());
    System.out.println(c.getSimpleName());
    System.out.println(c.getSuperclass());

    Class[] interfaces = c.getInterfaces();
    for (Class anInterface : interfaces) {
      System.out.println(anInterface);
    }
    //外部类类只有两种访问权限修饰(public 和 default)
    int modifiers = c.getModifiers();
  }

感谢阅读，希望能帮助到大家，谢谢大家对本站的支持！

您可能感兴趣的文章:

详解Java并发编程之内置锁(synchronized)
这篇文章主要介绍了Java并发编程之内置锁(synchronized)的相关知识，本文给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
2021-03-03
解决mybatis分页插件PageHelper导致自定义拦截器失效
这篇文章主要为大家介绍了解决mybatis分页插件PageHelper导致自定义拦截器失效方案示例，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪
2022-08-08
浅析SpringBoot中常见的底层注解
Spring Boot 是一个用于创建独立的、基于Spring框架的Java应用程序的框架，它提供了许多注解，下面小编就来和大家介绍一些常见的底层注解吧
2023-08-08
Java中常用的五种List声明并赋值操作方式
在Java编程中经常会使用到集合类来存储和操作多个元素,List是一种常见的集合类,它允许存储重复的元素,并且保持元素的插入顺序,这篇文章主要给大家介绍了关于Java中常用的五种List声明并赋值操作的相关资料,需要的朋友可以参考下
2024-02-02
如何将Java对象转换为JSON实例详解
有时候需要将对象转换为JSON格式,所以这篇文章主要给大家介绍了关于如何将Java对象转换为JSON的相关资料,文中通过实例代码介绍的非常详细,需要的朋友可以参考下
2022-08-08
springboot中的springSession的存储和获取实现
这篇文章主要介绍了springboot中的springSession的存储和获取实现，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
2020-09-09
详解SpringBoot实现事件同步与异步监听
这篇文章主要通过示例为大家详细介绍了SpringBoot中的事件的用法和原理以及如何实现事件同步与异步监听，快跟随小编一起学习学习吧
2022-06-06
spring boot 日志/页面处理、实体类构建、后台管理功能的实现
这篇文章主要介绍了spring boot 日志/页面处理、实体类构建、后台管理功能的实现,本文给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下
2021-08-08
谈谈Java 线程池
这篇文章主要介绍了Java 线程池的相关资料，帮助大家更好的理解和学习Java，感兴趣的朋友可以了解下
2020-08-08
SpringBoot 过滤器 Filter使用实例详解
这篇文章主要为大家介绍了SpringBoot 过滤器Filter使用实例详解，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪
2022-10-10

java 反射机制详解及实例代码

相关文章

最新评论

大家感兴趣的内容

最近更新的内容

常用在线小工具