1. 什么是反射?
1.1. 问题1
1.对象有编译类型和运行类型
Object obj = new java.util.Date();
编译类型:Object
运行类型(其实就是obj对象真实的类型):java.util.Date
需求:根据对象obj调用Date类中的一个方法,toLocaleString,如何来做?
obj.toLocaleString()代码在编译阶段去编译类型Object中检查是否有该方法,若没有,编译失败.
解决方案1:强制转换obj为Date类型,前提:必须知道对象的真实类型是什么?
Date d = (Date)obj;
d.toLocaleString();//YES
如果我不知道obj的真实类型,那又如何去调用toLolcaeString方法. 如何去做?
解决方案2: 使用反射
1.2. 问题2
对象使用类描述的,但是Java中一些皆对象,其实所有的类,底层都有一个字节码对象,用什么来描述这一个个类底层的字节码对象
解决方案 : 使用反射
1.3. 反射
反射:(reflection):在运行时期,动态地去获取类中的信息(类的信息,方法信息,构造器信息,字段等信息进行操作);
一个类中包含的信息有: 构造器,字段,方法
如何使用反射描述这些相关的信息
Class : 描述类
Method : 描述方法
Constructor :描述构造器
Field :描述字段
2. 获取类的Class实例三种方式
在反射操作某一个类之前,应该先获取这个类的字节码实例
获取字节码实例有三种方式
注意:同一个类在JVM的字节码实例只有一份
1. 类名.class
2. 类的对象.getClass()
3. Class.forName(“类的全限定名”)
(1) 全限定名 = 包名 + 类名
public class User {
@Test
public void testName() throws Exception {
//1.使用类名.class 获取类的字节码实例
Class clz1 = User.class;
System.out.println(clz1.toString());
//2.对象.getClass()
User user = new User();
Class> clz2 = user.getClass();
System.out.println(clz2);
//3.Class.forName("全限定名"):用的最多
Class> clz3 = Class.forName("cn.sxt.reflect.User");
System.out.println(clz3);
}
}
3. 获取九大内置类的字节码实例
对于对象来说,可以直接使用对象.getClass()或者Class.forName(className); 类名.class都可以获取Class实例.
但是我们的基本数据类型,就没有类的权限定名,也没有getClass方法.
问题: 那么如何使用Class类来表示基本数据类型的Class实例?
八大基本数据类型和 void关键字都是有 字节码实例的
byte,short,int,long,char,float,double,boolean ,void关键字
答 : 数据类型/void.class 即可
每个基本数据类型都是包装类型 如 :int ----Integer包装类型
注意: 基本数据类型和包装数据类型底层的字节码实例是不相同
//获取8大基本数据类型和void的字节码实例
//byte,short,int,long,char,float,double,boolean ,void关键字
public class BaiscDataTypeClassTest {
@Test
public void testName() throws Exception {
//1.获取byte的字节码实例
Class> byteClz = byte.class;
System.out.println(byteClz);
//....
//获取void关键字的字节码实例
Class> voidClz =void.class;
System.out.println(voidClz);
//所有的基本数据类型都有包装类型
//int---Integer
//int 和Integer 的字节码是绝对不相等的
Class> intClz1 = int.class;
Class> intClz2 = Integer.class;
System.out.println(intClz1);
System.out.println(intClz2);
System.out.println(intClz1 == intClz2);
}
}
4. 获取数组类型的字节码实例
表示数组的Class实例:
String[] sArr1 = {"A","C"};
Class clz = String[].class;//此时clz表示就是一个String类型的一位数组类型
所有具有相同元素类型和维数的数组才共享同一份字节码(Class对象);
注意:和数组中的元素没有一点关系.
package cn.sxt.reflect._01.getclass;
import static org.junit.Assert.*;
import org.junit.Test;
//获取数组类型的字节码实例
public class ArrayClassTest {
@Test
public void testName() throws Exception {
//定义数组
int[] arr = {1,2,3};
Class clz1 = (Class)arr.getClass();
System.out.println(clz1);
Class clz2= int[].class;
System.out.println(clz2);
int[] arr2 = {2,3,4};
Class clz3 = (Class)arr2.getClass();
System.out.println(clz3);
System.out.println(clz1 == clz2);//true
System.out.println(clz1 == clz3);//true
}
}
5. 构造函数-Constructor
5.1. 获取构造函数
类的构函数有 有参数构造函数,无参构造函数,公共构造函数,非公共构造函数,根据不同的构造函数 Class提供了几种获取不同构造函数的方法
(Class>... parameterTypes)
获取指定的公共构造函数
parameterTypes: 如果构造函数有参数,传递的是参数的字节码实例
(Class>... parameterTypes)
获取和访问权限无关的指定的构造函数
//通过字节码实例获取构造器
public class ConstructorTest {
@Test
public void testName() throws Exception {
//1.获取Student的字节码实例
Class> stuClz = Student.class;
//2.获取所有的公共构造函数
Constructor>[] cts1 = stuClz.getConstructors();
for (Constructor> ct : cts1)
{
System.out.println(ct);
}
System.out.println("----------------------");
//3.获取所有的构造函数包括私有的
Constructor>[] cts2 = stuClz.getDeclaredConstructors();
for (Constructor> ct : cts2)
{
System.out.println(ct);
}
System.out.println("----------------------");
//4.获取指定的构造函数(clz.getConstructor(...))只能获取公共的构造函数
Constructor> ct1 = stuClz.getConstructor();
System.out.println(ct1);
Constructor> ct2 =stuClz.getConstructor(String.class);
System.out.println(ct2);
//4.获取指定的构造函数(clz.getDeclaredConstructor(...))获取的构造函数和权限没有关系
Constructor> ct3=stuClz.getDeclaredConstructor(String.class,int.class);
System.out.println(ct3);
}
}
5.2. 调用构造函数创建对象
调用构造器,创建对象
Constructor类:表示类中构造器的类型,Constructor的实例就是某一个类中的某一个构造器
常用方法:
public T
newInstance(Object... initargs):如调用带参数的构造器,只能使用该方式.
参数:initargs:表示调用构造器的实际参数
返回:返回创建的实例,T表示Class所表示类的类型
如果:一个类中的构造器可以直接访问,同时没有参数.,那么可以直接使用Class类中的newInstance方法创建对象.
public Object newInstance():相当于new 类名();
调用私有的构造器:
5.2.1.
Constructor 创建对象的方法
(Object... initargs)
使用此 Constructor 对象表示的构造方法来创建该构造方法的声明类的新实例,并用指定的初始化参数初始化该实例。
5.2.2.
Class类中创建对象的方法
如果使用Class直接创建对象,必须保证类中有一个无参数公共构造函数
()
创建此 Class 对象所表示的类的一个新实例。
5.2.3.
设置忽略访问权限
默认执行私有构造函数报如下错误
如果是私有构造方法,反射默认是无法直接执行的,找到父类中AccessibleObject的方法,设置为true,即可忽略访问权限
void
(boolean flag)
如果执行私有方法,设置忽略访问权限 为 true即可
//使用构造器创建对象
public class NewInstanceTest {
@Test
public void testName() throws Exception {
//1.获取Student的字节码实例
Class> clz = Class.forName("cn.sxt.reflect.Student");
//1.1如果类有无参数公共构造函数,直接可以使用类的字节码实例就创建对象
Student stu0 = (Student) clz.newInstance();
//2.获取一个参数的构造函数
Constructor ct1 = (Constructor)clz.getConstructor(String.class);
//2.1.创建对象
Student stu1 = ct1.newInstance("东方不败");
//3.获取私有构造函数并创建对象
Constructor ct2 = (Constructor)clz.getDeclaredConstructor(String.class,int.class);
//3.1设置权限可以创建对象
ct2.setAccessible(true);
//3.2创建对象
Student stu2 = ct2.newInstance("西门吹雪",50);
}
}
6.
操作方法-Method
一个类创建对象以后,一般就要执行对象的方法等等,使用反射操作对象
首先要获取方法,再去执行
6.1. 获取方法和方法的执行
一个类中的方法有很多,无参,有参,静态,可变参数私有方法,等等,针对不同的方法处理,提供了不同的获取方案
6.1.1.
使用Class 获取对应的方法
()
获取所有的公共方法,包括父类的公共方法
(String name,
Class>... parameterTypes)
获取指定方法名称的方法,和访问权限无关
Name: 指定的方法名称
parameterTypes: 方法参数的类型
6.1.2.
Method执行方法
方法获取以后就需要执行。Method对象中提供方法执行的功能
(Object obj,
Object... args)
执行方法
Obj :如果是对象方法,传指定的对象,如果是类方法,传 null
Args: 方法的参数
如果方法有返回结果,可以接收
6.1.3.
设置忽略访问权限
如果是私有方法,反射默认是无法直接执行的,找到父类中AccessibleObject的方法,设置为true,即可忽略访问权限
void
(boolean flag)
如果执行私有方法,设置忽略访问权限 为 true即可
6.2. 方法操作的代码
6.2.1.
Student类
package cn.sxt.reflect._03method;
import java.util.Arrays;
public class Person {
public void hell1() {
System.out.println("我是无参数无返回值方法");
}
public String hello2(String name) {
return "你好 :"+name;
}
private String
hello3(Stringname,intage) {
return "我是 :"+name+",今年 :"+age;
}
public static void staticMethod(String name) {
System.out.println("我是静态方法 :"+name);
}
public static void method1(int[] intArr) {
System.out.println(Arrays.toString(intArr));
}
public static void method2(String[] strArr) {
System.out.println(Arrays.toString(strArr));
}
}
6.2.2.
测试类
package cn.sxt.reflect._03method;
import static org.junit.Assert.*;
import java.lang.reflect.Method;
import org.junit.Test;
//获取Person类的方法
public class GetMethodTest {
@Test
public void testName() throws Exception {
// 1.获取Person字节码实例
Class clz = Person.class;
// 2.创建对象
Person p = clz.newInstance();
// 3.获取方法(使用反射),获取所有公共方法,包含父类的公共方法
Method[] methods1 = clz.getMethods();
for (Method method : methods1) {
System.out.println(method);
}
System.out.println("------------------------------");
// 4.获取自己类中的所有方法(包括私有)
Method[] methods2 = clz.getDeclaredMethods();
for (Method method : methods2) {
System.out.println(method);
}
System.out.println("------------------------------");
// 4.获取单个指定名称的方法
Method method = clz.getMethod("hello2",
String.class);
System.out.println(method);
// 4.1执行方法
Object res = method.invoke(p, "陆小凤");
System.out.println(res);
// 5.获取私有的方法
Method hello3 = clz.getDeclaredMethod("hello3",
String.class, int.class);
System.out.println(hello3);
// 5.1设置忽略访问权限
hello3.setAccessible(true);
Object res1 = hello3.invoke(p, "叶孤城", 30);
System.out.println(res1);
// 6.获取静态方法
Method staticMethod = clz.getMethod("staticMethod",
String.class);
// 6.1执行静态方法
staticMethod.invoke(null, "花满楼");
// 7.获取有整数数组参数的方法
Method method1 = clz.getMethod("method1",
int[].class);
method1.invoke(null, new Object[] {new int[] { 1, 2, 3, 4 }});
// 8.获取有整数数组参数的方法
/*
* 如果反射传递的参数是引用类型,底层有一个拆箱的功能,会将数组的元素拆成一个个参数传递过来
* 解决方案: 将数组外面在包装一层数组,如果拆箱一次,得到还是一个数组
*/
Method method2 = clz.getMethod("method2",
String[].class);
method2.invoke(null,new Object[] {new String[] {"AA","BB","CC"}});
}
}
6.2.3.
可变参数的方法执行
如果方法中有可变参数(数组),如果反射传递的可变参数是引用类型,底层有一个拆箱的功能,会将数组的元素拆成一个个参数传递过来
解决方案: 将数组外面在包装一层数组,如果拆箱一次,得到还是一个数组
package cn.sxt.reflect._03method;
import java.util.Arrays;
public class Person {
public static void method1(int... intArr) {
System.out.println(Arrays.toString(intArr));
}
public static void method2(String...strArr) {
System.out.println(Arrays.toString(strArr));
}
}
// 7.获取有整数数组参数的方法
Method method1 = clz.getMethod("method1",
int[].class);
method1.invoke(null, new Object[] {new int[] { 1, 2, 3, 4 }});
// 8.获取有整数数组参数的方法
/*
* 如果反射传递的参数是引用类型,底层有一个拆箱的功能,会将数组的元素拆成一个个参数传递过来
* 解决方案: 将数组外面在包装一层数组,如果拆箱一次,得到还是一个数组
*/
Method method2 = clz.getMethod("method2",
String[].class);
method2.invoke(null,new Object[] {new String[] {"AA","BB","CC"}});
7.
操作字段(成员变量)-Field
类中的字段有各种数据类型和各种访问权限,针对这些情况,反射操作有对应的方法来获取和处理
7.1. Class中获取字段方法
获取当前Class所表示类中所有的public的字段,包括继承的字段.
获取当前Class所表示类中所有的字段,不包括继承的字段.
获取当前Class所表示类中
:获取当前Class所表示类中该fieldName名字的字段,不包括继承的字段.
7.2. Field操作设置值/获取值
给某个类中的字段设置值和获取值:
1,找到被操作字段所在类的字节码
2,获取到该被操作的字段对象
3,设置值/获取值
Field类常用方法:
void setXX(Object obj, XX value) :为基本类型字段设置值,XX表示基本数据类型
void set(Object obj, Object value) :表示为引用类型字段设置值
参数:
obj:
表示字段底层所属对象,若该字段是static的,该值应该设为null
value:
表示将要设置的值
-------------------------------------------------------------------------------------
XX getXX(Object obj) :获取基本类型字段的值,XX表示基本数据类型
Object get(Object obj) :表示获取引用类型字段的值
参数:
obj:
表示字段底层所属对象,若该字段是static的,该值应该设为null
返回:返回该字段的值.
void
设置引用类型的值,非基本数据类型
Obj: 要设置值得对象
Value : 要设置的值
package cn.sxt.reflect._04Field;
import static org.junit.Assert.*;
import java.lang.reflect.Field;
import org.junit.Test;
public class FieldTest {
@Test
public void testName() throws Exception {
//1.获取People字节码
Class clz = People.class;
People p = clz.newInstance();
//2.获取所有公共字段
Field[] fields1 = clz.getFields();
for (Field field : fields1) {
System.out.println(field);
}
System.out.println("---------------------");
//3.获取所有字段,和访问权限无关
Field[] fields2 = clz.getDeclaredFields();
for (Field field : fields2) {
System.out.println(field);
}
System.out.println("---------------------");
//3.获取指定的公共字段
Field emialField = clz.getField("emial");
System.out.println(emialField);
//为字段设置值
emialField.set(p, "zhagnsan@qq.com");
System.out.println(p);
//4.获取指定所有的字段,和访问权限无关
Field nameFiled = clz.getDeclaredField("name");
System.out.println(nameFiled);
//设置忽略访问权限
nameFiled.setAccessible(true);
nameFiled.set(p, "张三");
System.out.println(p);
//5 获取age字段
Field ageFile = clz.getDeclaredField("age");
ageFile.setAccessible(true);
//设置忽略访问权限
ageFile.setInt(p, 18);
System.out.println(p);
}
}
8.
Class的其他API方法
//Class字节码的其他api
@Test
public void testName() throws Exception {
//1.获取UserDaoImpl的字节码实例
Class> clz = Class.forName("cn.sxt.reflect._05otherapi.UserDaoImpl");
//2.获取所有的接口
Class>[] interfaces = clz.getInterfaces();
for (Class> intface : interfaces) {
System.out.println(intface);
}
//3.获取全限定名
System.out.println(clz.getName());
//4.获取简单类名
System.out.println(clz.getSimpleName());
//5.获取包
System.out.println(clz.getPackage().getName());
}
9.
JavaBean
问题: 什么是javaBean?
答: JavaBean就是一个个Java类,在java中符合JavaBean特点类才叫做JavaBean
9.1. JavaBean的三个特点
JavaBean类的修饰符必须是public,也就是一个JavaBean必须是一个对应一个类文件
JavaBean必须有无参数公共构造方法(以便于反射直接通过直接通过字节码实例创建对象)
3.JavaBean中的成员变量/字段必须有get/set方法提供对应的属性
9.1.1.
JavaBean中的属性
Java类有成员变量,成员变量绝对不是属性,JavaBean中的属性是有get/set方法确定的
9.1.1.1.
Get方法确定属性
public String getName() {
return name;
}
属性确定规则 : get方法去掉 get前缀 ,剩余部分 首字母小写
属性名称 : name
9.1.1.2.
Set方法确定属性
public void setName(String name) {
this.name
= name;
}
属性确定规则 : set方法去掉 set前缀 ,剩余部分 首字母小写
属性名称 : name
如果一个成员变量get/set方法都有确定的属性就只有一个
问题 :get/set方法确定确定的属性一般不就和成员变量一样啊,为什么要有属性了
答: 一般情况下,Eclipse工具有自动生成get/set方法的功能,确定的JavaBean的属性只是恰好和成员变量相同,但是成员变量不是属性
如下特殊性情况,属性和成员变量名称不同
//Filed
private String firstName;
//Filed
private String lastName;
//属性 :
fullName
public String getFullName() {
return this.firstName + this.lastName;
}
10. 小结
1. 理解反射概念?反射能干啥?
(1) 反射: 在jvm运行阶段,动态的获取类的信息(字节码实例,构造器,方法,字段),动态进行对象的创建,方法执行,字段操作。
2. 反射的常用类
(1) Class :所有类的字节码实例的描述
(2) Constructor :构造器
(3) Method :方法
(4) Field :字段
3. JDBC+反射 代码封装
(1) 通用 crud 方法
① 思路清晰