1、反射出现的背景
- 1.Java程序中，所有的对象都有两种类型：
编译时类型和运行时类型，而很多时候对象的编译时类型和运行时类型不一致。 Object obj = new String(“hello”); obj.getClass();例如：某些变量或形参的声明类型是Object类型，但是程序却需要调用该对象运行时类型的方法，该方法不是Object中的方法，那么如何解决呢？解决这个问题，有两种方案： - 1.方案1：在
编译和运行时都完全知道类型的具体信息，在这种情况下，我们可以直接先使用instanceof运算符进行判断，再利用强制类型转换符将其转换成运行时类型的变量即可 - 2.方案2：
编译时根本无法预知该对象和类的真实信息，程序只能依靠运行时信息来发现该对象和类的真实信息，这就必须使用反射
2、什么是Java的反射机制？
1.
动态语言：是指的在运行的时候改变自身结构的语言，例如新的函数、对象、甚至代码可以被引进，已有的函数可以被删除或其他结构上的变化。通俗的说就是代码可以根据某些条件改变自身结构，如PHP、Python等
2.静态语言：运行时结构不可以发生改变，如C、Java;
Java虽是静态语言，但是具有一定的动态性,可以利用其反射机制、字节码操作获取类似动态语言的特性
-
1.反射机制就是可以让程序在执行期间借助
反射API取得任何类的内部任何信息（如变量，构造器，成员方法等），并且可以操作任意对象的属性及方法； -
2.
加载完类之后，在堆中产生一个Class类型的对象（一个类永远都是只有一个Class对象），这个对象包含了类的完整结构信息。通过这个对象得到类完整的结构。这个对象就像是一面镜子，通过这个镜子看到类的结构，所以就称之为：反射
-
4.反射在设计模式和常用的框架底层都很常用
PS：对于反射的定义，直接看官方的定义还是有点难理解，下面是
更加通俗点的说法：
- 1.一般情况下，我们使用某个类，都会知道这个类，以及要用它来做什么，可以直接通过new实例化创建对象，然后使用这个对象对类进行操作，这个就属于
正射~ - 2.而反射则是一
开始并不知道要初始化的是什么类，无法使用new来实例化创建对象，主要是通过JDK提供的反射API来实现，在运行时才知道要操作的是什么类，并且可以获取到类的完整构造以及调用对应的方法，这就是反射~
3、从内存加载上看反射：
4、非反射机制调用方法与反射机制调用方法的对比：
4.1.环境准备：
定义一个类及方法,为后面使用非反射机制和反射机制调用方法做准备
- 1.定义SystemService类：
package com.powernode.reflect;
public class SystemService {
public void logout(){
System.out.println("退出系统");
}
public boolean login(String username, String password){
if ("admin".equals(username) && "admin123".equals(password)) {
return true;
}
return false;
}
public boolean login(String username){
if ("admin".equals(username)) {
return true;
}
return false;
}
}
4.2.体验非反射机制调用方法
a.实现调用类中的方法：
package com.powernode.reflect;
public class ReflectTest01 {
public static void main(String[] args) {
// 创建对象
SystemService systemService = new SystemService();
// 调用方法并接收方法的返回值
boolean success = systemService.login("admin", "admin123");
System.out.println(success ? "登录成功" : "登录失败");
}
}
b.执行结果：
非反射调用一个方法步骤：
- 调用哪个对象的（systemService）
- 哪个方法（login）
- 传什么参数（“admin”, “admin123”）
- 返回什么值（success）
4.3.体验反射机制调方法：
要使用反射机制调用一个方法，
首先要想办法获取到这个方法。在反射机制中Method实例代表的是一个方法
- 1.如果要获取logout()、login(String,String)、login(String) 这三个方法，首先
需要获取这个类Class
Class clazz = Class.forName("com.powernode.reflect.SystemService");
Object obj = clazz.newInstance(); //建对象
- 2.当拿到Class之后，调用
getDeclaredMethod()方法可以获取到方法。假如你要获取这个方法：login(String username, String password)
Method loginMethod = clazz.getDeclaredMethod("login", String.class, String.class);
- 3.假如你要获取到这个方法：login(String password)
Method loginMethod = clazz.getDeclaredMethod("login", String.class);
获取一个方法，
需要告诉Java程序，你要获取的方法的名字是什么，这个方法上每个形参的类型是什么。这样Java程序才能给你拿到对应的方法。这样的设计也非常合理，因为在同一个类当中，方法是支持重载的，也就是说方法名可以一样，但参数列表一定是不一样的，所以获取一个方法需要提供方法名以及每个形参的类型
- 4.第三步：调用方法
Object retValue = loginMethod.invoke(obj, "admin", "admin123"); //调用login方法
解说四要素：
- 哪个对象：obj
- 哪个方法：loginMethod
- 传什么参数：“admin”, “admin123”
- 返回什么值：retValue
5、反射机制提供了哪些功能？
- 1.可以在
运行时判断任意一个对象所属类 - 2.可以在
运行时构造一个类的对象 - 3.可以在
运行时得到任意一个类所具有的成员变量和方法 - 4.在运行时
获取泛型的信息 - 5.可以在
运行时调用任意一个类所具有的成员变量方法 - 6.生成
动态代理
6、反射相关的API:
java.lang.Class：代表一个类
java.lang.reflect.Method：代表类的方法
java.lang.reflect.Field：代表类的成员变量
java.lang.reflect.Constructor：代表类的构造器
… …
6.1.API介绍：
- 1.
java.lang.Class:代表一个类，Class对象表示某个类加载后在堆中的对象,Class就是描述类的一个类。
- 2.
java.lang.reflect.Method:代表类的方法,Metho对象就代表某个类的方法 - 3.
java.lang.reflect.Field:代表类的成员变量，Field对象就代表某个类的成员变量。 - 4.
java.lang.reflect.Constructor:代表类的构造方法，Constructor对象就代表构造器
上面的这4个类都在
java.lang.reflection中
6.2.编码测试：
a.案例1测试：
- 1.创建Person类：
package com.atguigu.java;
public class Person {
private String name;
public int age;
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
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;
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
private Person(String name) {
this.name = name;
}
public Person() {
System.out.println("Person()");
}
public void show(){
System.out.println("你好，我是一个人");
}
private String showNation(String nation){
System.out.println("我的国籍是：" + nation);
return nation;
}
}
- 2.反射之前，对于Person的操作
@Test
public void test1() {
//1.创建Person类的对象
Person p1 = new Person("Tom", 12);
//2.通过对象，调用其内部的属性、方法
p1.age = 10;
System.out.println(p1.toString());
p1.show();
System.out.println("------------------------------------------------");
//在Person类外部，不可以通过Person类的对象调用其内部私有结构。
//比如：name、showNation()以及私有的构造器
}
- 3.有了反射，对于Person的操作：
package com.atguigu.java;
import org.junit.Test;
import java.lang.annotation.ElementType;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class ReflectionTest {
//反射之后，对于Person的操作
@Test
public void test2() throws Exception{
// 获取Class类的实例：对象Person的运行时类
Class clazz = Person.class;
//1.通过反射，通过调用参数构造器，来创建Person类的对象
Constructor cons = clazz.getConstructor(String.class,int.class);//反射调用Person类的构造器
Object obj = cons.newInstance("Tom", 12);//相当于创建Person类对象，相当于之前的new Person()这步
Person p = (Person) obj;
System.out.println(p.toString());
//2.通过反射，调用对象指定的属性、方法
//调用属性
Field age = clazz.getDeclaredField("age");
age.set(p,10);// 更改属性的值变为10
System.out.println(p.toString());
//调用方法
Method show = clazz.getDeclaredMethod("show");
show.invoke(p);
System.out.println("*******************************");
//通过反射，可以调用Person类的私有结构的。比如：私有的构造器、方法、属性
//调用私有的构造器
Constructor cons1 = clazz.getDeclaredConstructor(String.class);
cons1.setAccessible(true);
Person p1 = (Person) cons1.newInstance("Jerry");
System.out.println(p1);
//调用私有的属性
Field name = clazz.getDeclaredField("name");
name.setAccessible(true);
name.set(p1,"HanMeimei");
System.out.println(p1);
//调用私有的方法
Method showNation = clazz.getDeclaredMethod("showNation", String.class);
showNation.setAccessible(true);
String nation = (String) showNation.invoke(p1,"中国");//相当于String nation = p1.showNation("中国")
System.out.println(nation);
}
}
b.案例2：
- 1.创建Car类：
- 2.代码测试：
package com.jianqun.reflection_.class_;
import com.jianqun.Car;
import java.lang.reflect.Field;
/**
*/
public class Car02 {
public static void main(String[] args) throws Exception {
String classAllPath = "com.jianqun.Car";
//1 . 获取到Car类 对应的 Class对象
//<?> 表示不确定的Java类型
Class<?> cls = Class.forName(classAllPath);
//2. 输出cls
System.out.println(cls); //显示cls对象, 是哪个类的Class对象 com.jianqun.Car
System.out.println(cls.getClass());//输出cls运行类型 java.lang.Class
//3. 得到包名
System.out.println(cls.getPackage().getName());//包名
//4. 得到全类名
System.out.println(cls.getName());
//5. 通过cls创建对象实例
Car car = (Car) cls.newInstance();
System.out.println(car);//car.toString()
//6. 通过反射获取属性 brand
Field brand = cls.getField("brand");
System.out.println("brand====" + brand);//public java.lang.String com.jianqun.Car.brand
System.out.println(brand.get(car));//宝马
//7. 通过反射给属性赋值
brand.set(car, "奔驰");
System.out.println(brand.get(car));//奔驰
//8 我希望大家可以得到所有的属性(字段)
System.out.println("=======所有的字段属性====");
Field[] fields = cls.getFields();
for (Field f : fields) {
System.out.println(f.getName());//名称
}
}
}
7、反射的优缺点：
7.1.优点：
- 可以
动态的创建和使用对象，使用灵活，没有反射机制，框架就失去了底层的支撑
7.2.缺点：
使用反射基本是解释执行，对执行的速度有影响
8、反射造对象和new方式造对象的选择：
8.1.疑问1：
通过
直接new的方式或反射的方式都可以调用公共的结构，开发中到底用那个？
- 1.建议：直接new的方式。效率相对高一些
- 2.在编译的时候，我们不知道应该new哪个类的对象，此时就可以使用反射。比如登录问题，根据用户请求的情况来造登录或注册的对象！
8.2.疑问2：
反射机制与面向对象中的封装性是不是矛盾的？如何看待两个技术？
- 两者肯定是不矛盾的。两者描述问题的方向不一样:
- 封装的意思就是说建议不使用私有属性或者方法，构造器啥的，因为在公共的里面，可能已经对这些成员使用了。
- 而
反射就是说如果非得想调用，那也可以调用，也是有办法调的。所以说并不冲突
8.3.代码测试反射的性能及优化：
- 1.编码代码比较执行时间：
package com.jianqun.reflection_.question;
import com.jianqun.Cat;
import java.io.FileInputStream;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Properties;
/**
* @author: jianqun
* @email: 1033586391@qq.com
* @creat: 2022-04-06-10:09
* @Description:
*/
public class ReflectionQuestion {
public static void main(String[] args) throws Exception{
m1();
m2();
}
public static void m1() throws Exception {
long l1 = System.currentTimeMillis();
Cat cat = new Cat();
for (int i = 0;i<9000000;i++){
cat.hi();
}
long l2 = System.currentTimeMillis();
System.out.println("传统方法耗时:" + (l2 - l1));
}
public static void m2() throws Exception {
// 得到一个Class类型的对象
Class cls = Class.forName("com.jianqun.Cat");
// 得到一个实例
Object o = cls.newInstance();
//得到一个Method类型的方法对象
Method method = cls.getMethod("hi");
long l1 = System.currentTimeMillis();
for (int i = 0;i<9000000;i++){
method.invoke(o);//反射机制调用方法
}
long l2 = System.currentTimeMillis();
System.out.println("反射方法耗时:" + (l2 - l1));
}
}
- 2.执行结果：
- 3.对于反射执行速度慢，可以进行优化
Method和Filed和Construct对象都有setAccessible()方法setAccessible作用是启动和禁止访问安全检查的开关- 参数
为true的时候，表示 反射的对象在使用时取消访问检查，提高反射的效率。参数为false表示要进行安全检查提高反射的效率。如果代码中必须用反射，而该句代码需要频繁的被调用，那么请设置为true。使得原本无法访问的私有成员也可以访问
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
