Java反射简单举例1. 什么是反射2. 类类3. 一切反射相关的代码都从获得类对象开始4. 反射三大作用(java.lang.reflect.*)

113 阅读 0 评论 75 点赞

我是靠谱客的博主精明砖头，最近开发中收集的这篇文章主要介绍Java反射简单举例1. 什么是反射2. 类类3. 一切反射相关的代码都从获得类对象开始4. 反射三大作用(java.lang.reflect.*)，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

1. 什么是反射

反射，java语言中的一种机制，通过这种机制可以动态的实例化对象、读写属性、调用方法

2. 类类

所有狗狗类 Dog 狗对象旺财

所有猫猫类 Cat 猫对象肥波

所有类类类 java.lang.Class 类对象特定类

狗类的实例是旺财，猫类的实例是肥波，类类的实例就是类。

狗类是类类的一个实例，猫类也是类类的一个实例，学生类也是类类的一个实例.........

狗类是描述所有的狗，猫类是描述所有的猫，类类就是描述所有的类

3. 一切反射相关的代码都从获得类对象开始

类对象：类对象就是类类的一个类的实例

类对象也称为类的实例

3.1 Class.forName(完整类名)

3.2 类名.class

3.3 对象.getClass()

注1：ClassNotFoundException(类名错|少jar包)

注2：同一类的、类对象只会创建一个

这是一个Student的测试类：

package com.lq.reflect;
public class Student {
private String sid;
private String sname;
public Integer age;
static{
System.out.println("加载进jvm中！");
}
public Student() {
super();
System.out.println("调用无参构造方法创建了一个学生对象");
}
public Student(String sid) {
super();
this.sid = sid;
System.out.println("调用带一个参数的构造方法创建了一个学生对象");
}
public Student(String sid, String sname) {
super();
this.sid = sid;
this.sname = sname;
System.out.println("调用带二个参数的构造方法创建了一个学生对象");
}
@SuppressWarnings("unused")
private Student(Integer age) {
System.out.println("调用Student类私有的构造方法创建一个学生对象");
this.age = age;
}
public String getSid() {
return sid;
}
public void setSid(String sid) {
this.sid = sid;
}
public String getSname() {
return sname;
}
public void setSname(String sname) {
this.sname = sname;
}
public void hello() {
System.out.println("你好！我是" + this.sname);
}
public void hello(String name) {
System.out.println(name + "你好！我是" + this.sname);
}
@SuppressWarnings("unused")
private Integer add(Integer a, Integer b) {
return new Integer(a.intValue() + b.intValue());
}
}

获取类对象：

package com.lq.reflect;
/**
*
* @ClassName: Demo1
* @Description: 获取类对象
* @author LQ
* @date 2019年2月22日 下午5:36:23
*
*/
public class Demo1 {
public static void main(String[] args)
throws ClassNotFoundException,
InstantiationException, IllegalAccessException {
// 1. Class.forname
// 通过全限定名进行获取
// clz 就是类对象（类类的类对象）
// Class<?> clz =
Class.forName("com.lq.reflect.Student");
// 2. 类名 . Class 通用查询方法
// Class clz=Student.class;
// 获取的是student类对象
// System.out.println(clz.newInstance());
// 3.通过具体的类实例拿到类类的类实例（对象 .
getClass） 通用的增删改方法
// Student stu=new Student();
// Class clz=stu.getClass();
// System.out.println(clz.newInstance());
// 反射怎么实例化对象 clz.newInstance(); 就是实例化对象
//通过反射去创建一个学生对象的实例
Class clz = Student.class;
Student stu = (Student) clz.newInstance();
}
}

4. 反射三大作用(java.lang.reflect.*)

4.1 实例化对象

c.newInstance()

Constructor.getConstructor/Constructor.getDeclaredConstructor

注：一定要提供无参构造器

4.2 动态调用方法

Method m;

m.invoke

4.3 读写属性

Field set/get

实例化对象：

package com.lq.reflect;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
/**
*
* @ClassName: Demo2
* @Description: 实例化对象
* @author LQ
* @date 2019年2月22日 下午8:25:45
*
*/
public class Demo2 {
public static void main(String[] args) throws InstantiationException, IllegalAccessException, NoSuchMethodException,
SecurityException, IllegalArgumentException, InvocationTargetException {
// 一切反射相关的代码都从获得类对象开始
Class clz = Student.class;
// 所有的类默认提供了一个无参构造器（以后创建类，提供了有参构造器后要提供无参构造器）
// clz.newInstance();
// -->
// Constructor c= clz.getConstructor();
// Object newInstance = c.newInstance();
// 调用带一个参数的构造方法创建了一个学生对象
// Constructor = Student (String.class)传参数
// Constructor c= clz.getConstructor(String.class);
// c.newInstance("哈哈");
// 调用带二个参数的构造方法创建了一个学生对象
// Constructor c= clz.getConstructor(String.class,String.class);
// c.newInstance("哈哈","SDSDS");
// getDeclaredConstructor与Constructor的区别
// Constructor：只能拿到OOP思想能实例化的构造器
// getDeclaredConstructor：只要是个构造器都能拿到
Constructor c = clz.getDeclaredConstructor(Integer.class);
// 访问私有构造器时，要打开它的权限
c.setAccessible(true);
c.newInstance(45);
}
}

动态调用方法：

package com.lq.reflect;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
/**
*
* @ClassName: Demo3
* @Description: 动态调用方法
* @author LQ
* @date 2019年2月22日 下午8:53:08
*
*/
public class Demo3 {
public static void main(String[] args) throws NoSuchMethodException, SecurityException, IllegalAccessException,
IllegalArgumentException, InvocationTargetException, InstantiationException {
// 一切反射相关的代码都从获得类对象开始
Class clz = Student.class;
// 第一种，调无参的
第一个参数：方法名
第二个参数：参数的类型
// Method method = clz.getMethod("hello");
第一个参数：具体的类的类实例
第二个参数：具体的参数值
// method.invoke(clz.newInstance());
//
第二种，调有参的
//
Method method = clz.getMethod("hello", String.class);
//
method.invoke(clz.newInstance(), "有点意思");
//
method.invoke( )返回值问题
//
如果说，被调用的方法，本身是void类型，那么method.invoke( )返回值就是null
//
如果说，被调用的方法，本身是非void类型，那么method.invoke( )返回值就是被调用的方法的返回值
Method method =
clz.getDeclaredMethod("add",Integer.class,Integer.class);
method.setAccessible(true);
Object invoke = method.invoke(clz.newInstance(),45,56);
System.out.println(invoke);
}
}

读写属性：

package com.lq.reflect;
import java.lang.reflect.Field;
/**
*
* @ClassName: Demo4
* @Description: 读写属性
* @author LQ
* @date 2019年2月22日 下午9:14:27
*
*/
public class Demo4 {
public static void main(String[] args) throws
NoSuchFieldException, SecurityException,
IllegalArgumentException, IllegalAccessException {
// 一切反射相关的代码都从获得类对象开始
Class clz = Student.class;
Student stu =new Student();
//
stu.age=22;
//
Field field = clz.getField("age");
第一个参数：具体的类的类实例
第二个参数：就是给field对象需要赋的值
field.set(stu, 18);
//
System.out.println("反射取值："+field.get(stu));
//
System.out.println("OOP取值："+stu.age);
//
输出：
//
加载进jvm中！
//
调用无参构造方法创建了一个学生对象
//
反射取值：22
//
OOP取值：22
//
stu.setSname("有点意思");
//
Field field = clz.getDeclaredField("sname");
//
field.setAccessible(true);
//
field.set(stu, "确实有点意思");
//
System.out.println("反射赋值："+field.get(stu));
//
System.out.println("OOP赋值："+stu.getSname());
//
输出：
//
加载进jvm中！
//
调用无参构造方法创建了一个学生对象
//
反射赋值：确实有点意思
//
OOP赋值：确实有点意思
stu.age=18;
stu.setSid("s001");
stu.setSname("张三");
//
反射取值
VS
oop取值
System.out.println(stu.age);
System.out.println(stu.getSid());
System.out.println(stu.getSname());
//
Dao层插入操作
Field[] declaredFields = clz.getDeclaredFields();
for (Field field : declaredFields) {
field.setAccessible(true);
System.out.println(field.getName()+","+field.get(stu));
}
//
输出：
//
加载进jvm中！
//
调用无参构造方法创建了一个学生对象
//
18
//
s001
//
张三
//
sid,s001
//
sname,张三
//
age,18
}
}