一个例子让你了解Java反射机制

最新推荐文章于 2024-09-21 10:38:43 发布
最新推荐文章于 2024-09-21 10:38:43 发布
阅读量427 收藏
点赞数
分类专栏： java 文章标签： java 反射机制

Java反射机制：

通俗地说,反射机制就是可以把一个类,类的成员(函数,属性),当成一个对象来操作,希望读者能理解,也就是说,类,类的成员,我们在运行的时候还可以动态地去操作他们.

理论的东东太多也没用，下面我们看看实践 Demo ～

Demo:


package  demo.reflect;
 
import  java.lang.reflect.*;
 
public  class  ReflectDemo {
 
     /**
      * 为了看清楚Java反射部分代码，所有异常我都最后抛出来给虚拟机处理
      */
     public  static  void  main(String[] args)  throws  ClassNotFoundException, IllegalAccessException, InstantiationException, InvocationTargetException, NoSuchFieldException, NoSuchMethodException {
 
         System.out.println( "demo1：通过Java反射机制得到类的包名和类名" );
         demo1();
 
         System.out.println( "" );
         System.out.println( "demo2：验证所有的类都是Class类的实例对象" );
         demo2();
 
         System.out.println( "" );
         System.out.println( "demo3：通过Java反射机制，用 Class 创建类对象，这也就是反射存在的意义所在" );
         demo3();
 
         System.out.println( "" );
         System.out.println( "demo4：通过Java反射机制得到一个类的构造函数，并实现创建带参实例对象" );
         demo4();
 
         System.out.println( "" );
         System.out.println( "demo5：通过Java反射机制操作成员变量, set 和 get" );
         demo5();
 
         System.out.println( "" );
         System.out.println( "demo6：通过Java反射机制得到类的一些属性：继承的接口、父类、函数信息、成员信息、类型等" );
         demo6();
 
         System.out.println( "" );
         System.out.println( "demo7：通过Java反射机制调用类方法" );
         demo7();
 
         System.out.println( "" );
         System.out.println( "demo8：通过Java反射机制得到类加载器信息" );
         demo8();
     }
 
     /**
      * demo1：通过Java反射机制得到类的包名和类名
      */
     public  static  void  demo1() {
         Person person =  new  Person();
         System.out.println( "包名："  + person.getClass().getPackage().getName());
         System.out.println( "完整类名："  + person.getClass().getName());
     }
 
     /**
      * demo2：验证所有的类都是Class类的实例对象
      */
     public  static  void  demo2()  throws  ClassNotFoundException {
         //定义两个类型都未知的Class，设置初值为null，看看如何给它们赋值成Person类
         Class<?> class1 =  null ;
         Class<?> class2 =  null ;
         //写法1，可能抛出 ClassNotFoundException 异常，多用这个写法
         class1 = Class.forName( "demo.reflect.Person" );
         System.out.println( "写法1，包名："  + class1.getPackage().getName() +  " , 完整类名："  + class1.getName());
         //写法2
         class2 = Person. class ;
         System.out.println( "写法2，包名："  + class2.getPackage().getName() +  " , 完整类名："  + class2.getName());
     }
 
     /**
      * demo3：通过Java反射机制，用 Class 创建类对象，这也就是反射存在的意义所在
      */
     public  static  void  demo3()  throws  ClassNotFoundException, InstantiationException, IllegalAccessException {
         Class<?> class1 =  null ;
         class1 = Class.forName( "demo.reflect.Person" );
         //由于这里不能带参数，所以你要实例化的这个类Person，一定要有无参构造函数
         Person person = (Person) class1.newInstance();
         person.setName( "xiaoming" );
         person.setAge( 20 );
         System.out.println(person.getName() +  " , "  + person.getAge());
     }
 
     /**
      * demo4：通过Java反射机制得到一个类的构造函数，并实现创建带参实例对象
      */
     public  static  void  demo4()  throws  ClassNotFoundException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
         Class<?> class1 =  null ;
         Person person1 =  null ;
         Person person2 =  null ;
 
         class1 = Class.forName( "demo.reflect.Person" );
         Constructor<?>[] constructors = class1.getConstructors();
 
         person1 = (Person) constructors[ 0 ].newInstance();
         person1.setName( "xiaoming" );
         person1.setAge( 20 );
         System.out.println(person1.getName() +  " , "  + person1.getAge());
         person2 = (Person) constructors[ 1 ].newInstance( 21 ,  "xiaohong" );
         System.out.println(person2.getName() +  " , "  + person2.getAge());
     }
 
     /**
      * demo5：通过Java反射机制操作成员变量, set 和 get
      */
     public  static  void  demo5()  throws  ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchFieldException, SecurityException {
         Class<?> class1 = Class.forName( "demo.reflect.Person" );
         Object obj = class1.newInstance();
         Field personNameField = class1.getDeclaredField( "name" );
         personNameField.setAccessible( true );  //取消访问检查
         personNameField.set(obj,  "小虎" );
         System.out.println( "修改属性之后得到属性变量的值："  + personNameField.get(obj));
     }
 
     /**
      * demo6：通过Java反射机制得到类的一些属性：继承的接口、父类、函数信息、成员信息、类型等
      */
     public  static  void  demo6()  throws  ClassNotFoundException {
         Class<?> class1 = Class.forName( "demo.reflect.SuperMan" );
 
         //取得父类名称
         Class<?> superclass = class1.getSuperclass();
         System.out.println( "SuperMan类的父类名："  + superclass.getName());
 
         Field[] fields = class1.getDeclaredFields();
         for  ( int  i =  0 ; i < fields.length; i++) {
             System.out.println( "类中的成员"  + i +  "： "  + fields[i]);
         }
 
         //取得类方法
         Method[] methods = class1.getDeclaredMethods();
         for  ( int  i =  0 ; i < methods.length; i++) {
             System.out.println( "取得SuperMan类的方法"  + i +  "：" );
             System.out.println( "函数名："  + methods[i].getName());
             System.out.println( "函数返回类型："  + methods[i].getReturnType());
             System.out.println( "函数访问修饰符："  + Modifier.toString(methods[i].getModifiers()));
             System.out.println( "函数代码写法： "  + methods[i]);
         }
 
         //取得类实现的接口，因为接口类也属于Class，所以得到接口中的方法也是一样的方法得到哈
         Class<?> interfaces[] = class1.getInterfaces();
         for  ( int  i =  0 ; i < interfaces.length; i++) {
             System.out.println( "实现的接口类名： "  + interfaces[i].getName());
         }
     }
 
     /**
      * demo7：通过Java反射机制调用类方法
      */
     public  static  void  demo7()  throws  ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException {
         Class<?> class1 = Class.forName( "demo.reflect.SuperMan" );
 
         System.out.println( "调用无参方法fly()：" );
         Method method = class1.getMethod( "fly" );
         method.invoke(class1.newInstance());
 
         System.out.println( "调用有参方法walk(int m)：" );
         method = class1.getMethod( "walk" ,  int . class );
         method.invoke(class1.newInstance(),  100 );
     }
 
     /**
      * 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 = Class.forName( "demo.reflect.SuperMan" );
         String name = class1.getClassLoader().getClass().getName();
         System.out.println( "类加载器类名："  + name);
     }
 
}
 
class  Person {
     private  int  age;
     private  String name;
 
     public  Person() {
 
     }
 
     public  Person( int  age, String name) {
         this .age = age;
         this .name = name;
     }
 
     public  int  getAge() {
         return  age;
     }
 
     public  void  setAge( int  age) {
         this .age = age;
     }
 
     public  String getName() {
         return  name;
     }
 
     public  void  setName(String name) {
         this .name = name;
     }
}
 
interface  ActionInterface {
     public  void  walk( int  m);
}
 
class  SuperMan  extends  Person  implements  ActionInterface {
     private  boolean  blueBriefs;
 
     public  void  fly() {
         System.out.println( "超人会飞耶～～" );
     }
 
     public  boolean  isBlueBriefs() {
         return  blueBriefs;
     }
 
     public  void  setBlueBriefs( boolean  blueBriefs) {
         this .blueBriefs = blueBriefs;
     }
 
     @Override
     public  void  walk( int  m) {
         System.out.println( "超人会走耶～～走了"  + m +  "米就走不动了！" );
     }
}

原文链接：http://my.oschina.net/zc741520/blog/195460
Xiamen_wiley
关注
专栏目录
Android 编译时View注入工具的实现
Runing的专栏
06-19 1684
Android 编译时View注入工具的实现 使用反射实现View注入 Java实现编译时注解 Android实现编译时注解View注入工具
Android 通过 annotation ViewInject
xyjikl
11-19 556
前言：  通常对控件的获取对象是通过sourceView.findViewById(R.id.xx)。通过获取控件的中的注解形式实现一些控件对象。 如： [java] view plaincopy @ViewInject(id=R.id.text_title)   TextView text_title;      @ViewI
Android-一个根据布局文件自动生成findViewById代码的androidstudio插件
08-12
一个根据布局文件自动生成findViewById代码的android studio插件
android ViewId自动注解使用详解（ViewInject）
风晴
01-23 3984
Annotation就是注解了，JDK1.5新增加功能，该功能可用于类，构造方法，成员变量，方法，参数等的声明中。 api版本23下，android studio里是直接可以使用的，不用添加依赖库，以前的api可能需要。下边介绍几种我觉得比较好用的注解。 NoNull注解 先看下源码 /** * Denotes that a parameter, field or method
java 反射机制
05-09
### Java反射机制深入理解 #### 一、反射机制概述 Java反射机制是一种强大的工具，它允许程序在运行时检查和操作任何类、方法、构造函数和字段等元素。这种能力对于构建灵活的应用程序和框架非常有用，特别是那些...
利用java反射机制实现自动调用类的简单方法
09-01
Java反射机制是Java语言提供的一种强大功能，它允许运行中的Java程序对自身进行检查并且可以直接操作程序的内部属性。在上述示例中，通过反射机制实现了动态调用类的方法，这种方式在某些场景下非常有用，比如插件...
java反射机制以及试验例子
04-04
有大量的实验例子和反射的各种方法说明，有大量的实验例子和反射的各种方法说明。
Android中@ViewInject的意思
qq_34561253的博客
02-20 2239
原文地址：https://zhidao.baidu.com/question/2076050702870028108.html依赖注入框架， 为了快速开发，百度 roboguice的用法，资料很多，就是利用反射原理将控件和事件绑定，节省你诸如 findViewById 这样的代码，写起来方便 。 优点： 开发速度快， 缺点： 对性能消耗略大。google官方不甚推荐。...
关于android Activity中注解的使用，省去无用的findviewbyid....setonclick.....
xadlovezy的专栏
07-10 444
这几天研究的一下java的反射与注解机制，又分析了开源的afinal框架发现里面用到了注解省去很多的findViewById和setonClick等方法，省去了很多的代码，而且代码一目了然，下面是我自己的心得自己的实现注解： package com.example.anotationdemo; import java.lang.annotation.Annotation; i
让写代码变成简单的copy操作，代码生成器之一---------android,findViewById
lyx2007825的专栏
12-01 2581
通过写一个简单的配置文件，自动扩展生成相应的代码，从而可以偷点小懒。 配置文件如下: TextView:money TextView:name TextView:age ImageView:headImg ruby 代码生成器如下: require 'erb' class FindViewById class << self def get_type_ab(type)
Android开发学习之路-让注解帮你简化代码，彻底抛弃findViewById
weixin_30354675的博客
04-05 303
本文主要是记录注解的使用的学习笔记，如有错误请提出。 在通常的情况下，我们在Activity中有一个View，我们要获得这个View的实例是要通过findViewById这个方法，然后这个方法返回的是一个Object类型，我们还需要进行强制的类型转换，但是相信很多人都遇到过，当我们的一个布局中有很多个控件的时候，每一个控件都要进行上面的这个操作其实是很烦躁的，特别是强制类型转换，即使是...
Java企业面试题3
m0_74972727的博客
09-15 886
1. break和continue的作用(智*图) break：用于完全退出一个循环（如 for, while）或一个 switch 语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。 continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在 for 循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。 2. if分支语句和switch分支语句的异同之处(智*图) 相同点：都是用来根据不同的条件执行不同的代码块。
Arthas sysenv（查看JVM的环境变量）
最新发布
刘大猫
09-21 188
Arthas sysenv（查看JVM的环境变量）
JDK17新增语法特性
2201_76124988的博客
09-20 521
从springboot3.0开始，已经不支持JDK8，转变为JDK17参考资料：官方博客。
faiss安装 （CPU版本）
CSDN_WHB的博客
09-20 175
faiss版本 faiss-v1.7.4。
举一个java反射机制的例子
06-03
Java反射机制是Java语言的一个特性，它允许程序在运行时动态地获取类的信息以及调用对象的方法。以下是一个简单的Java反射机制的例子： ``` public class Person { private String name; private int age; public Person(String name, int age) { this.name = name; this.age = age; } public void introduce() { System.out.println("My name is " + name + ", and I am " + age + " years old."); } } public class ReflectExample { public static void main(String[] args) throws Exception { Person person = new Person("Tom", 25); Class<?> clazz = person.getClass(); Field nameField = clazz.getDeclaredField("name"); nameField.setAccessible(true); String name = (String) nameField.get(person); System.out.println("The person's name is " + name); Method introduceMethod = clazz.getDeclaredMethod("introduce"); introduceMethod.invoke(person); } } ``` 在上面的例子中，我们创建了一个Person类，该类包含一个私有的name和age属性以及一个introduce()方法。在ReflectExample类中，我们首先获取了Person对象的Class对象，然后使用Class对象获取了Person类的name属性和introduce()方法，并使用反射机制调用了introduce()方法和获取了Person对象的name属性的值。这个例子展示了Java反射机制的一些基本用法。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值