反射

获取类的方法:

  1. Class<?> aClass1 = Class.forName("TestDemo.refection.User");//通过类路径获取
  3. Class<User> userClass = User.class;//通过类名获取
  5. User user = new User();
  6. Class<? extends User> aClass = user.getClass();//通过实例对象获取

无论通过哪种方式获取，获取几个都是一个Class的实例：

  1. Class<?> aClass1 = Class.forName("TestDemo.refection.User");
  2. Class<?> aClass2 = Class.forName("TestDemo.refection.User");
  4. Class<User> userClass = User.class;
  6. User user = new User();
  7. Class<? extends User> aClass = user.getClass();
  9. System.out.println(aClass1.hashCode());
  10. System.out.println(aClass2.hashCode());
  11. System.out.println(userClass.hashCode());
  12. System.out.println(aClass.hashCode());
  14. /*
  15. 结果：
  16. 1360875712
  17. 1360875712
  18. 1360875712
  19. 1360875712
  21. 可以看出它们的hashCode都是一样的
  22. */

通过反射获取相应的Class类后，获取相应的方法、属性、构造器

  1. public class Test04 {
  3.     public static void main(String[] args) throws Exception {
  4.         Class<?> aClass = Class.forName("TestDemo.refection.User1");
  6.         System.out.println(aClass.getName());//获取全类名
  7.         System.out.println(aClass.getSimpleName());//获取简单的类名
  9.         System.out.println("=========================================");
  11.         Field[] fields = aClass.getFields();//获取公有的属性
  12.         for (Field field : fields) {
  13.             System.out.println("public:" +field);
  14.         }
  16.         fields = aClass.getDeclaredFields();//获取全部（包括公有和私有）的属性
  17.         for (Field field : fields) {
  18.             System.out.println("getDeclaredFields:" +field);
  19.         }
  21.         System.out.println("=========================================");
  23.         System.out.println("获取所有公有的方法，包括父类的：");
  24.         Method[] methods = aClass.getMethods();
  25.         for (Method method : methods) {
  26.             System.out.println(method);
  27.         }
  29.         System.out.println("获取自己所有的方法，包括私有的：");
  30.         methods = aClass.getDeclaredMethods();
  31.         for (Method method : methods) {
  32.             System.out.println(method);
  33.         }
  35.         System.out.println("获取指定的公有的方法（包括父类的方法）：");
  36.         Method setName = aClass.getMethod("setName", String.class);
  37.         System.out.println(setName);
  38.         Method notify = aClass.getMethod("notify");
  39.         System.out.println(notify);
  41.         System.out.println("获取指定的全部的方法（包括父类的方法，包括私有的方法）：");
  42.         Method test = aClass.getDeclaredMethod("test");
  43.         System.out.println(test);
  45.         System.out.println("=========================================");
  47.         System.out.println("获取全部公有（自身的）的构造器：");
  48.         Constructor<?>[] constructors = aClass.getConstructors();
  49.         for (Constructor<?> constructor : constructors) {
  50.             System.out.println(constructor);
  51.         }
  53.         System.out.println("获取全部（自身的，包括私有的）的构造器");
  54.         constructors = aClass.getDeclaredConstructors();
  55.         for (Constructor<?> constructor : constructors) {
  56.             System.out.println(constructor);
  57.         }
  59.         System.out.println("获取指定的构造器（不包括私有的）：");
  60.         System.out.println(aClass.getConstructor());
  62.         System.out.println("获取指定的构造器（包括私有的）：");
  63.         System.out.println(aClass.getDeclaredConstructor(String.class));
  65.     }
  66. }
  68. class Fater1{
  69.     public Fater1(){}
  71. }
  73. class User1 extends Fater1{
  74.     private String name;
  75.     private int id;
  76.     public int age;
  78.     public User1() {
  79.     }
  81.     private User1(String name) {
  82.         this.name = name;
  83.     }
  85.     public User1(String name, int id, int age) {
  86.         this.name = name;
  87.         this.id = id;
  88.         this.age = age;
  89.     }
  91.     public String getName() {
  92.         return name;
  93.     }
  95.     public void setName(String name) {
  96.         this.name = name;
  97.     }
  99.     public int getId() {
  100.         return id;
  101.     }
  103.     public void setId(int id) {
  104.         this.id = id;
  105.     }
  107.     public int getAge() {
  108.         return age;
  109.     }
  111.     public void setAge(int age) {
  112.         this.age = age;
  113.     }
  115.     private void test(){
  116.         System.out.println("私有方法");
  117.     }
  119.     @Override
  120.     public String toString() {
  121.         return "User1{" +
  122.                 "name='" + name + '\'' +
  123.                 ", id=" + id +
  124.                 ", age=" + age +
  125.                 '}';
  126.     }
  127. }
  129. /*
  130. 结果：
  131. TestDemo.refection.User1
  132. User1
  133. =========================================
  134. public:public int TestDemo.refection.User1.age
  135. getDeclaredFields:private java.lang.String TestDemo.refection.User1.name
  136. getDeclaredFields:private int TestDemo.refection.User1.id
  137. getDeclaredFields:public int TestDemo.refection.User1.age
  138. =========================================
  139. 获取所有公有的方法，包括父类的：
  140. public java.lang.String TestDemo.refection.User1.toString()
  141. public java.lang.String TestDemo.refection.User1.getName()
  142. public int TestDemo.refection.User1.getId()
  143. public void TestDemo.refection.User1.setName(java.lang.String)
  144. public void TestDemo.refection.User1.setAge(int)
  145. public int TestDemo.refection.User1.getAge()
  146. public void TestDemo.refection.User1.setId(int)
  147. public final void java.lang.Object.wait() throws java.lang.InterruptedException
  148. public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
  149. public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException
  150. public boolean java.lang.Object.equals(java.lang.Object)
  151. public native int java.lang.Object.hashCode()
  152. public final native java.lang.Class java.lang.Object.getClass()
  153. public final native void java.lang.Object.notify()
  154. public final native void java.lang.Object.notifyAll()
  155. 获取自己所有的方法，包括私有的：
  156. public java.lang.String TestDemo.refection.User1.toString()
  157. public java.lang.String TestDemo.refection.User1.getName()
  158. public int TestDemo.refection.User1.getId()
  159. public void TestDemo.refection.User1.setName(java.lang.String)
  160. private void TestDemo.refection.User1.test()
  161. public void TestDemo.refection.User1.setAge(int)
  162. public int TestDemo.refection.User1.getAge()
  163. public void TestDemo.refection.User1.setId(int)
  164. 获取指定的公有的方法（包括父类的方法）：
  165. public void TestDemo.refection.User1.setName(java.lang.String)
  166. public final native void java.lang.Object.notify()
  167. 获取指定的全部的方法（包括父类的方法，包括私有的方法）：
  168. private void TestDemo.refection.User1.test()
  169. =========================================
  170. 获取全部公有（自身的）的构造器：
  171. public TestDemo.refection.User1(java.lang.String,int,int)
  172. public TestDemo.refection.User1()
  173. 获取全部（自身的，包括私有的）的构造器
  174. public TestDemo.refection.User1(java.lang.String,int,int)
  175. private TestDemo.refection.User1(java.lang.String)
  176. public TestDemo.refection.User1()
  177. 获取指定的构造器（不包括私有的）：
  178. public TestDemo.refection.User1()
  179. 获取指定的构造器（包括私有的）：
  180. private TestDemo.refection.User1(java.lang.String)
  181. */

反射创建对象实例（Constructor）、方法（Method）、属性（Field）：

  1. public class Test05 {
  3.     public static void main(String[] args) throws Exception {
  4.         Class<?> aClass = Class.forName("TestDemo.refection.AAA");
  6.         System.out.println("创建一个对象的实例，使用的无参构造器：");
  7.         AAA aaa = (AAA)aClass.newInstance();//如果没有无参构造器就会报错
  8.         System.out.println(aaa);
  9.         System.out.println("创建一个对象的实例，使用的有参构造器：");
  10.         AAA aaa1 =  (AAA)aClass.getConstructor(int.class, String.class).newInstance(1,"水三丫");
  11.         System.out.println(aaa1);
  12.         System.out.println("创建一个对象的实例，使用的私有有参构造器：");
  13.         Constructor<?> declaredConstructor = aClass.getDeclaredConstructor(int.class);
  14.         //需要关闭权限，才可以使用私有的构造器
  15.         declaredConstructor.setAccessible(true);
  16.         AAA aaa2 =  (AAA)declaredConstructor.newInstance(1);
  17.         System.out.println(aaa2);
  19.         System.out.println("===============================================");
  20.         System.out.println("反射使用一个公有方法：");
  21.         AAA aaa4 = (AAA)aClass.newInstance();//如果没有无参构造器就会报错
  22.         aClass.getMethod("setName", String.class).invoke(aaa4,"水三丫");
  23.         System.out.println(aaa4);
  25.         System.out.println("反射使用一个公有方法：");
  26.         AAA aaa5 = (AAA)aClass.newInstance();//如果没有无参构造器就会报错
  27.         Method test = aClass.getDeclaredMethod("test");
  28.         test.setAccessible(true);
  29.         test.invoke(aaa5);
  31.         System.out.println("================================================");
  32.         System.out.println("反射获取一个公有属性：");
  33.         AAA aaa6 = (AAA)aClass.newInstance();//如果没有无参构造器就会报错
  34.         Field field = aClass.getField("name");
  35.         field.set(aaa6,"水三丫");
  36.         System.out.println(aaa6);
  37.         System.out.println("反射获取一个私有属性：");
  38.         Field field1 = aClass.getDeclaredField("id");
  39.         field1.setAccessible(true);//关闭权限
  40.         field1.set(aaa6,1);
  41.         System.out.println(aaa6);
  42.     }
  43. }
  45. class AAA{
  46.     private int id;
  47.     public String name;
  49.     public AAA() {
  50.     }
  52.     private AAA(int id) {
  53.         this.id = id;
  54.     }
  56.     public AAA(int id, String name) {
  57.         this.id = id;
  58.         this.name = name;
  59.     }
  61.     public int getId() {
  62.         return id;
  63.     }
  65.     public void setId(int id) {
  66.         this.id = id;
  67.     }
  69.     public String getName() {
  70.         return name;
  71.     }
  73.     public void setName(String name) {
  74.         this.name = name;
  75.     }
  77.     private void test(){
  78.         System.out.println("我是私有的方法");
  79.     }
  81.     @Override
  82.     public String toString() {
  83.         return "AAA{" +
  84.                 "id=" + id +
  85.                 ", name='" + name + '\'' +
  86.                 '}';
  87.     }
  88. }
  90. /*
  91. 结果：
  93. 创建一个对象的实例，使用的无参构造器：
  94. AAA{id=0, name='null'}
  95. 创建一个对象的实例，使用的有参构造器：
  96. AAA{id=1, name='水三丫'}
  97. 创建一个对象的实例，使用的私有有参构造器：
  98. AAA{id=1, name='null'}
  99. ===============================================
  100. 反射使用一个公有方法：
  101. AAA{id=0, name='水三丫'}
  102. 反射使用一个公有方法：
  103. 我是私有的方法
  104. ================================================
  105. 反射获取一个公有属性：
  106. AAA{id=0, name='水三丫'}
  107. 反射获取一个私有属性：
  108. AAA{id=1, name='水三丫'}
  110. */

反射获取泛型：

  1. public class Test06 {
  3.     public static void main(String[] args) throws Exception {
  4.         Class<BB> bbClass = BB.class;
  6.         System.out.println("获取参数类型");
  7.         Method method = bbClass.getMethod("test01", Map.class, List.class);
  8.         //获取类型
  9.         Type[] genericParameterTypes = method.getGenericParameterTypes();
  10.         for (Type genericParameterType : genericParameterTypes) {
  11.             System.out.println(genericParameterType);
  12.             //获取单个真实的泛型
  13.             if(genericParameterType instanceof ParameterizedType){
  14.                 Type[] actualTypeArguments = ((ParameterizedType) genericParameterType).getActualTypeArguments();
  15.                 for (Type actualTypeArgument : actualTypeArguments) {
  16.                     System.out.println(actualTypeArgument);
  17.                 }
  18.             }
  19.         }
  21.         System.out.println("===========================================");
  22.         System.out.println("获取返回值类型");
  23.         Method test02 = bbClass.getDeclaredMethod("test02", List.class);
  24.         Type genericReturnType = test02.getGenericReturnType();
  25.         System.out.println(genericReturnType);
  26.         if(genericReturnType instanceof ParameterizedType){
  27.             Type[] actualTypeArguments = ((ParameterizedType) genericReturnType).getActualTypeArguments();
  28.             for (Type actualTypeArgument : actualTypeArguments) {
  29.                 System.out.println(actualTypeArgument);
  30.             }
  31.         }
  33.         System.out.println("===========================================");
  34.         System.out.println("获取未定型的返回值类型");
  35.         Method test03 = bbClass.getDeclaredMethod("test03");
  36.         Type genericReturnType1 = test03.getGenericReturnType();
  37.         System.out.println(genericReturnType1);
  38.     }
  39. }
  41. class BB{
  43.     public void test01(Map<String,BB> map, List<BB> list){
  44.         System.out.println("test01");
  45.     }
  47.     public Map<String,BB> test02(List<BB> list){
  48.         System.out.println("test01");
  49.         return null;
  50.     }
  52.     public <T>T  test03(){
  53.         return null;
  54.     }
  56. }
  58. /*
  59. 结果：
  60. 获取参数类型
  61. java.util.Map<java.lang.String, TestDemo.refection.BB>
  62. class java.lang.String
  63. class TestDemo.refection.BB
  64. java.util.List<TestDemo.refection.BB>
  65. class TestDemo.refection.BB
  66. ===========================================
  67. 获取返回值类型
  68. java.util.Map<java.lang.String, TestDemo.refection.BB>
  69. class java.lang.String
  70. class TestDemo.refection.BB
  71. ===========================================
  72. 获取未定型的返回值类型
  73. T
  74. */

java反射的初理解的更多相关文章

  1. JAVA反射机制及理解

    JAVA反射 往往当我们面对一项新的知识时,我们往往需要知道三个方面,它是什么,它能做什么,它比原有知识强在哪里,我们该怎么使用它.当你能够解决这些问题时,便意味着你已经对这项知识入门了. 首先: 反 ...

  2. Java反射的浅显理解

    一.回顾反射相关的知识 1.在xml文件中使用反射的好处: 1)代码更加灵活,后期维护只需要修改配置文件即可 · 初学者一般习惯于在代码本身上直接修改,后期也可以修改配置文件达到相同的目的 · 修改配 ...

  3. 我对java反射机制的理解

    我们平常怎么用一个使用类,怎么使用类的方法?其实就是创建一个对象,并且通过这个对象调用这个方法.不过这有一个问题,就是这个对象的载体就和这个对象产生了耦合,怎么降低两者间的耦合呢?java的反射机制就 ...

  4. java反射机制的理解

    反射机制是什么概念?大多都有介绍,指的是程序在运行状态中,能够加载一个只有类名的类,加载完之后会在堆上产生一个Class对象.通过这个 Class对象可以获得类的属性.方法和其他类信息.之前对反射的应 ...

  5. Java反射的一些理解

    1.Class对象 VS. 实例对象 在Java中我们一般是这样使用类的:编写类,然后new对象,再调用方法.这里new出来的对象暂且称之为实例对象(instance).其实在这之前还涉及到一个Cla ...

  6. JAVA反射机制_获取字节码文件对象

    是在运行状态中,对于任意一个类 (class文件),都能够知道这个类的所有属性和方法:对于任意一个对象,都能够调用它的任意一个方法和属性: 这种动态获取的信息以及动态调用对象的方法的功能称为java语 ...

  7. Java反射机制获取Class文件

    JAVA反射机制是在运行状态中,对于任意一个类(class文件),都能够知道这个类的所有属性和方法:对于任意一个对象,都能够调用它的任意一个方法和属性:这种动态获取的信息以及动态调用对象方法的功能称为 ...

  8. java反射机制 + Method.invoke解释 getMethod + 反射理解

    功能: 通过读取另一个Dll去创建一个控件(Form,Button,TextBox,DataGridView),然后对当中一些属性进行检查. 创建控件的大致流程是,Assembly->Modul ...

  9. (转)JAVA反射机制理解

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

随机推荐

  1. 认识并安装WSL

    认识并安装WSL(基于Windows的Linux子系统) 什么是WSL WSL(Windows Subsystem for Linux),这是在windows平台运行的linux子系统.也就是说可是不 ...

  2. 992. Sort Array By Parity II - LeetCode

    Question 992. Sort Array By Parity II Solution 题目大意:给一个int数组,一半是奇数一半是偶数,分别对偶数数和奇数数排序并要求这个数本身是偶数要放在偶数 ...

  3. Spring 源码（16）Spring Bean的创建过程（7）属性填充

    知识回顾 上一篇介绍了Spring中三级缓存的singletonObjects.earlySingletonObjects.singletonFactories,Spring在处理循环依赖时在实例化后 ...

  4. 好客租房48-组件的props（基本使用）

    组件是封闭的 要接受外部数据应该通过props来实现 props的作用:接受传递给组件的数据 传递数据:给组件标签添加属性 接收数据:函数组件通过参数props接收数据 类组件通过this.props ...

  5. 个人冲刺（四阶段）——体温上报app（一阶段）

    任务:完成了后台数据库的类模块 MyDBHelper.java package com.example.helloworld; import android.content.Context; impo ...

  6. BSP-充电名词解释

    充电名词解释 A~G H~N O~T U~Z A~G ACA = accessory charger adapter = 辅助充电适配器 ACC = apparent charge capacity ...

  7. 《HALCON数字图像处理》第五章笔记

    目录 第五章 图像运算 图像的代数运算 加法运算 图像减法 图像乘法 图像除法 图像逻辑运算(位操作) 图像的几何变换 图像几何变换的一般表达式 仿射变换 投影变换 灰度插值 图像校正 我在Gitee ...

  8. 配置中心的设计-nacos vs apollo

    简介 前面我们分析了携程的 apollo(见 详解apollo的设计与使用),现在再来看看阿里的 nacos. 和 apollo 一样,nacos 也是一款配置中心,同样可以实现配置的集中管理.分环境 ...

  9. JAVA - 线程同步和线程调度的相关方法

    JAVA - 线程同步和线程调度的相关方法 wait():使一个线程处于等待(阻塞)状态,并且释放所持有的对象的锁:wait是Object类的方法,对此对象调用wait方法导致本线程放弃对象锁,进入等 ...

  10. 深度学习与CV教程(12) | 目标检测 (两阶段,R-CNN系列)

    作者:韩信子@ShowMeAI 教程地址:http://www.showmeai.tech/tutorials/37 本文地址:http://www.showmeai.tech/article-det ...