「java反射教学」java反射的实现

本篇文章给大家谈谈java反射教学，以及java反射的实现对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。

本文目录一览：

• 1、学习java应该如何理解反射?
• 2、java中反射实例类装载的步骤及简要阐述
• 3、北大青鸟java培训：JAVA反射机制原理？
• 4、反射机制在java中如何做呀？
• 5、北大青鸟java培训：Java高级开发必须懂的反射是什么样的？
• 6、java课程分享Java的反射机制

学习java应该如何理解反射?

反射机制:所谓的反射机制就是java语言在运行时拥有一项自观的能力。通过这种能力可以彻底的了解自身的情况为下一步的动作做准备。

下面具体介绍一下java的反射机制。

Java的反射机制的实现要借助于4个类:class，Constructor，Field，Method;

其中class代表的时类对 象，Constructor-类的构造器对象，Field-类的属性对象，Method-类的方法对象。通过这四个对象我们可以粗略的看到一个类的各个组 成部分。

Java反射的作用:

在Java运行时环境中，对于任意一个类，可以知道这个类有哪些属性和方法。对于任意一个对象，可以调用它的任意一个方法。这种动态获取类的信息以及动态调用对象的方法的功能来自于Java 语言的反射(Reflection)机制。

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

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

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

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

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

反射的常用类和函数:Java反射机制的实现要借助于4个类:Class，Constructor，Field，Method;

其中class代表的是类对象，Constructor-类的构造器对象，Field-类的属性对象，Method-类的方法对象，通过这四个对象我们可以粗略的看到一个类的各个组成部分。其中最核心的就是Class类，它是实现反射的基础，它包含的方法我们在第一部分已经进行了基本的阐述。应用反射时我们最关心的一般是一个类的构造器、属性和方法，下面我们主要介绍Class类中针对这三个元素的方法:

1、得到构造器的方法：在对于学习java的同学们来说看了也不知道怎么去做的在，在做的过程当中遇到困难可以加扣：五七8接着再来不要断开0二四后面跟着再来一四4连在一起即可，进行交流同时得到大神的指导和帮助。Constructor getConstructor(Class[] params) -- 获得使用特殊的参数类型的公共构造函数，

Constructor[] getConstructors() -- 获得类的所有公共构造函数

Constructor getDeclaredConstructor(Class[] params) -- 获得使用特定参数类型的构造函数(与接入级别无关)

Constructor[] getDeclaredConstructors() -- 获得类的所有构造函数(与接入级别无关)

2、获得字段信息的方法

Field getField(String name) -- 获得命名的公共字段

Field[] getFields() -- 获得类的所有公共字段

Field getDeclaredField(String name) -- 获得类声明的命名的字段

Field[] getDeclaredFields() -- 获得类声明的所有字段

3、获得方法信息的方法

Method getMethod(String name, Class[] params) -- 使用特定的参数类型，获得命名的公共方法

Method[] getMethods() -- 获得类的所有公共方法

Method getDeclaredMethod(String name, Class[] params) -- 使用特写的参数类型，获得类声明的命名的方法

Method[] getDeclaredMethods() -- 获得类声明的所有方法

在程序开发中使用反射并结合属性文件，可以达到程序代码与配置文件相分离的目的

如果我们想要得到对象的信息，一般需要“引入需要的‘包.类’的名称--通过new实例化--取得实例化对象”这样的过程。使用反射就可以变成“实例化对象--getClass()方法--得到完整的‘包.类’名称”这样的过程。

正常方法是通过一个类创建对象，反射方法就是通过一个对象找到一个类的信息。

java中反射实例类装载的步骤及简要阐述

java反射和类装载

反射机制：

Person p=new Person();

这是什么?当然是实例化一个对象了.可是这种实例化对象的方法存在一个问题,那就是必须要知道类名才可以实例化它的对象,这样我们在应用方面就会受到限制.那么有没有这样一种方式,让我们不知道这个类的类名就可以实例化它的对象呢?Thank Goodness!幸亏我们用的是java, java就提供了这样的机制.

1).java程序在运行时可以获得任何一个类的字节码信息,包括类的修饰符(public,static等),基类(超类,父类),实现的接口,字段和方法等信息.

2).java程序在运行时可以根据字节码信息来创建该类的实例对象,改变对象的字段内容和调用对象方法.

这样的机制就叫反射技术.可以想象光学中的反射,就像我们照镜子,镜子中又出现一个自己(比喻可能不太恰当,但是足以表达清楚意思了).反射技术提供了一种通用的动态连接程序组件的方法,不必要把程序所需要的目标类硬编码到源程序中,从而使得我们可以创建灵活的程序.

反射的实现步骤（ 不问不需要答) ，

1、获取类的常用方式有三种： a) Class.forName("包名.类名")，最常用、推荐；b) 包名.类名.class 最简捷；c) 对象.getClass 的方式获得。

2、对象的实例化,上面已经获取了类，只需要调用类的实例化方法,类.newInstance()便可。

3、获取属性和构造等，可以参考 JavaApi 的调用，类. getDeclaredFields,类. getConstructor(..)等。

Java的反射机制是通过反射API来实现的,它允许程序在运行过程中取得任何一个已知名称的类的内部信息.反射API位于java.lang.reflect包中.主要包括以下几类:

1).Constructor类:用来描述一个类的构造方法

2).Field类:用来描述一个类的成员变量

3).Method类:用来描述一个类的方法.

4).Modifer类:用来描述类内各元素的修饰符

5).Array:用来对数组进行操作.

Constructor,Field,Method这三个类都是JVM(虚拟机)在程序运行时创建的,用来表示加载类中相应的成员.这三个类都实现了java.lang.reflect.Member接口,Member接口定义了获取类成员或构造方法等信息的方法.要使用这些反射API,必须先得到要操作的对象或类的Class类的实例.通过调用Class类的newInstance方法(只能调用类的默认构造方法)可以创建类的实例.这样有局限性,我们可以先冲类的Class实例获取类需要的构造方法,然后在利用反射来创建类的一个实例.

类加载机制：



类的加载机制可以分为加载-链接-初始化三个阶段，链接又可以分为验证、准备、解析三个过程。

加载：通过类的加载器查找并加载二进制字节流的过程，在堆内存中的方法区生成 一个代表这个类的 java.lang.Class 对象，作为这个类的数据请求入口。（这里可以把上面类加载器加载文件的过程描述一下（参考版本一，不作重复））。

验证：主要是对一些词法、语法进行规范性校验，避免对 JVM 本身安全造成危害； 比如对文件格式，字节码验证，无数据验证等。但验证阶段是非必须的，可以通过参数 设置来进行关闭，以提高加载的时效。

准备：对类变量分配内存，并且对类变量预初始化，初始化成数据类型的原始值， 比如 static int a=11,会被初始化成成 a=0;如果是 static double a =11,则会被初始化成 a=0.0； 而成员变量只会成实例化后的堆中初始化。

解析：把常量池中的符号引用转换为直接引用的过程。

初始化：对类的静态变量和静态块中的变量进行初始化。（上面的准备阶段可以作为 预初始化，初始到变量类型的原值，但如果被 final 修饰会进行真正初始化）

上面加载、链接、初始化的各个阶段并不是彼此独立，而是交叉进行，这点很重要 。

***class.forName和 classloader的区别

Class.forName 和 ClassLoader 都是用来装载类的，对于类的装载一般为分三个阶段加载、链接、编译，它们装载类的方式是有区别。

首先看一下 Class.forName（..），forName（..）方法有一个重载方法 forName(className,boolean,ClassLoader)，它有三个参数，第一个参数是类的包路径，第二个参数是 boolean

类型，为 true 地表示 Loading 时会进行初始化，第三个就是指定一个加载器；当你调用class.forName(..)时，默认调用的是有三个参数的重载方法，第二个参数默认传入 true,第三个参数默认使用的是当前类加载时用的加载器。

ClassLoader.loadClass()也有一个重载方法，从源码中可以看出它默认调的是它的重载 方法 loadClass(name, false)，当第二参数为 false 时，说明类加载时不会被链接。这也是两者之间最大区别，前者在加载的时候已经初始化，后者在加载的时候还没有链接。如果你需要在加载时初始化一些东西，就要用 Class.forName 了，比如我们常用的驱动加载， 实际上它的注册动作就是在加载时的一个静态块中完成的。所以它不能被 ClassLoader 加载代替。

北大青鸟java培训：JAVA反射机制原理？

运行时类型识别(Run-timeTypeIdentification,RTTI)主要有两种方式，一种是我们在编译时和运行时已经知道了所有的类型，另外一种是功能强大的“反射”机制。

要理解RTTI在Java中的工作原理，首先必须知道类型信息在运行时是如何表示的，这项工作是由“Class对象”完成的，它包含了与类有关的信息。

类是程序的重要组成部分，每个类都有一个Class对象，每当编写并编译了一个新类就会产生一个Class对象，它被保存在一个同名的.class文件中。

在运行时，当我们想生成这个类的对象时，运行这个程序的Java虚拟机(JVM)会确认这个类的Class对象是否已经加载，如果尚未加载，JVM就会根据类名查找.class文件，并将其载入，一旦这个类的Class对象被载入内存，它就被用来创建这个类的所有对象。

一般的RTTI形式包括三种：1.传统的类型转换。

如“(Apple)Fruit”，由RTTI确保类型转换的正确性，如果执行了一个错误的类型转换，就会抛出一个ClassCastException异常。

2.通过Class对象来获取对象的类型。

如Classc=Class.forName(“Apple”);Objecto=c.newInstance();3.通过关键字instanceof或Class.isInstance()方法来确定对象是否属于某个特定类型的实例，准确的说，应该是instanceof/Class.isInstance()可以用来确定对象是否属于某个特定类及其所有基类的实例，这和equals()/==不一样，它们用来比较两个对象是否属于同一个类的实例，没有考虑继承关系。

反射如果不知道某个对象的类型，可以通过RTTI来获取，但前提是这个类型在编译时必须已知，这样才能使用RTTI来识别。

即在编译时，编译器必须知道所有通过RTTI来处理的类。

使用反射机制可以不受这个限制，它主要应用于两种情况，第一个是“基于构件的编程”，在这种编程方式中，将使用某种基于快速应用开发(RAD)的应用构建工具来构建项目。

这是现在最常见的可视化编程方法，通过代表不同组件的图标拖动到图板上来创建程序，然后设置构件的属性值来配置它们。

这种配置要求构件都是可实例化的，并且要暴露其部分信息，使得程序员可以读取和设置构件的值。

当处理GUI时间的构件时还必须暴露相关方法的细细，以便RAD环境帮助程序员覆盖这些处理事件的方法。

在这里，就要用到反射的机制来检查可用的方法并返回方法名。

Java通过JavaBeans提供了基于构件的编程架构。

第二种情况，在运行时获取类的信息的另外一个动机，就是希望能够提供在跨网络的远程平台上创建和运行对象的能力。

这被成为远程调用(RMI)，它允许一个Java程序将对象分步在多台机器上，湖南java培训认为这种分步能力将帮助开发人员执行一些需要进行大量计算的任务，充分利用计算机资源，提高运行速度。

反射机制在java中如何做呀？

首先大体介绍下反射机制：JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。 举个简单的列子 import java.lang.reflect.Constructor; import java.lang.reflect.Field; import java.lang.reflect.Method; public class ReflectTester { /** * 通过java的反射机制获取类的所有属性和方法 */ public void test1() { try { Class c = Class.forName("demo1.client.Customer"); System.out.println("属性："); Field f[] = c.getDeclaredFields(); for (int i = 0; i f.length; i++) { System.out.println(f[i].getName()); } System.out.println("方法："); Method m[] = c.getDeclaredMethods(); for (int i = 0; i m.length; i++) { System.out.println(m[i].toString()); } } catch (Throwable e) { System.err.println(e); } } /** * 通过java的反射机制动态修改对象的属性 * @param o */ public void test2(Customer o) { try { Class c = o.getClass(); //getMethod方法第一个参数指定一个需要调用的方法名称，第二个参数是需要调用方法的参数类型列表，如无参数可以指定null，该方法返回一个方法对象 Method sAge = c.getMethod("setAge", new Class[] { int.class }); Method gAge = c.getMethod("getAge", null); Method sName = c.getMethod("setName", new Class[] { String.class }); //动态修改Customer对象的age Object[] args1 = { new Integer(25) }; sAge.invoke(o, args1); //动态取得Customer对象的age Integer AGE = (Integer) gAge.invoke(o, null); System.out.println("the Customer age is: " + AGE.intValue()); //动态修改Customer对象的name Object[] args2 = { new String("李四") }; sName.invoke(o, args2); } catch (Throwable e) { System.err.println(e); } } /** * 通过java的反射机制做一个简单对象的克隆 * @param o * @return */ public Object test3(Customer o) { Object o2 = null; try { Class c = o.getClass(); //通过默认构造方法创建一个新的对象 o2 = c.getConstructor(new Class[] {}).newInstance( new Object[] {}); Field fields[] = c.getDeclaredFields(); for (int i = 0; i fields.length; i++) { Field field = fields[i]; String fieldName = field.getName(); String firstLetter = fieldName.substring(0, 1).toUpperCase(); // 获得和属性对应的getXXX()方法的名字 String getMethodName = "get" + firstLetter + fieldName.substring(1); // 获得和属性对应的setXXX()方法的名字 String setMethodName = "set" + firstLetter + fieldName.substring(1); // 获得和属性对应的getXXX()方法 Method getMethod = c.getMethod(getMethodName, new Class[] {}); // 获得和属性对应的setXXX()方法 Method setMethod = c.getMethod(setMethodName, new Class[] { field.getType() }); // 调用原对象的getXXX()方法 Object value = getMethod.invoke(o, new Object[] {}); // 调用拷贝对象的setXXX()方法 setMethod.invoke(o2, new Object[] { value }); } } catch (Throwable e) { System.err.println(e); } return o2; } public static void main(String[] args) throws Exception { ReflectTester t = new ReflectTester(); t.test1(); Customer customer = new Customer(); customer.setAge(20); customer.setName("张三"); System.out.println("调用前name: " + customer.getName()); System.out.println("调用前age: " + customer.getAge()); t.test2(customer); System.out.println("调用后name: " + customer.getName()); System.out.println("调用后age: " + customer.getAge()); Customer customer2 = (Customer)t.test3(customer); System.out.println("克隆对象的name: " + customer2.getName()); System.out.println("克隆对象的age: " + customer2.getAge()); } } class Customer { private long id; private String name; private int age; public Customer() { } public Customer(String name, int age) { this.name = name; this.age = age; } public long getId() { return id; } public void setId(long id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } 你可以自己运行下看看，再修改一些看看

北大青鸟java培训：Java高级开发必须懂的反射是什么样的？

理解反射对学习Java框架有很大的帮助，如Spring框架的核心就是使用Java反射实现的，而且对做一些Java底层的操作会很有帮助。

一、Class类的使用1、万事万物皆对象，（当然，基本数据类型，静态成员不是面向对象（属于类的）），所以我们创建的每一个类也都是对象，即类本身是java.lang.Class类的实例对象，但是这些对象都不需要new出来，因为java.lang.Class类的构造方法是私有的2、任何一个类都是Class类的实例对象，这个实例对象有三种表示方式：(我们新建一个Student类)（上海尚学堂java全程老师面授＋实战教学）①Classc1=Student.class;//实际告诉我们任何一个类都有一个隐含的静态成员变量class（知道类名时用）②Classc2=stu.getClass();//已知该类的对象通过getClass方法（知道对象时用）③Classc3=Class.forName("类的全名");//会有一个ClassNotFoundException异常官网解释说：c1,c2表示了Student类的类类型（）classtype)，万事万物皆对象，类也是对象，是Class类的实例对象，这个对象我们成为该类的类类型（有点乱，但是慢慢捋一下还是能理解的）这里有一点值得注意，当我们执行System.out.println(c1==c2);语句，结果返回的是true，这是为什么呢？原因是不管c1还是c2都代表了Student类的类类型，一个类可能是Class类的一个实例对象。

我们完全可以通过类的类类型创建该类的对象实例，即通过c1或c2创建Student的实例。

Studentstu=(Student)c1.newInstance();//前提是必须要有无参的构造方法，因为该语句会去调用其无参构造方法。

该语句会抛出异常。

二、动态加载类1、编译时加载类是静态加载类，new创建对象是静态加载类，在编译时刻就需要加载所有可用使用到的类，如果有一个用不了，那么整个文件都无法通过编译2、运行时加载类是动态加载类Classc= Class.forName("类的全名")，不仅表示了类的类型，还表示了动态加载类，编译不会报错，在运行时才会加载，使用接口标准能更方便动态加载类的实现。

功能性的类尽量使用动态加载，而不用静态加载。

辽宁电脑培训发现很多软件比如QQ,360的在线升级，并不需要重新编译文件，只是动态的加载新的东西。

java课程分享Java的反射机制

Java反射机制是一个非常强大的功能，在很多大型项目比如Spring,Mybatis都可以看见反射的身影。通过反射机制我们可以在运行期间获取对象的类型信息，利用这一特性我们可以实现工厂模式和代理模式等设计模式，同时也可以解决Java泛型擦除等令人苦恼的问题。下面java课程就从实际应用的角度出发，来应用一下Java的反射机制。

反射基础

p.s:本文需要读者对反射机制的API有一定程度的了解，如果之前没有接触过的话，建议先看一下官方文档的QuickStart。

在应用反射机制之前，首先我们先来看一下如何获取一个对象对应的反射类Class，在Java中我们有三种方法可以获取一个对象的反射类。

通过getClass方法

在Java中，每一个Object都有一个getClass方法，通过getClass方法我们可以获取到这个对象对应的反射类：

Strings="ziwenxie";

Class?c=s.getClass();

通过forName方法

我们也可以调用Class类的静态方法forName：

Class?c=Class.forName("java.lang.String");

使用.class

或者我们也可以直接使用.class：

Class?c=String.class;

获取类型信息

在文章开头我们就提到反射的一大好处就是可以允许我们在运行期间获取对象的类型信息，下面我们通过一个例子来具体看一下。

首先我们在typeinfo.interfacea包下面新建一个接口A：

packagetypeinfo.interfacea;

publicinterfaceA{voidf();}

接着我们在typeinfo.packageaccess包下面新建一个接口C，接口C继承自接口A，并且我们还另外创建了几个用于测试的方法，注意下面几个方法的权限都是不同的。

java反射教学的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于java反射的实现、java反射教学的信息别忘了在本站进行查找喔。