本文介绍了Java反射机制，可操作字节码文件让程序更灵活，阐述获取Class的三种方式及通过反射实例化对象的方法，验证了其灵活性。还提及资源绑定器，便于获取属性配置文件内容。此外，讲解了类加载器，包括启动、扩展和应用类加载器，以及保证类加载安全的双亲委派机制。
反射机制（一）
概述
通过java语言中的反射机制可以操作字节码文件（可以读和修改字节码文件）。
作用：可以让程序更加灵活
反射机制的相关类在：java.lang.reflect.*
相关的主要的类有：
- java.lamg.Class 代表字节码文件，代表一个类型
- java.lang.reflect.Method 代表字节码中的方法字节码，代表类中的方法
- java.lang.reflect.Constructor 代表字节码中的构造方法字节码，代表类中的构造方法
- java.lang.reflect.Field 代表字节码中的属性字节码，代表类中的成员变量（包括静态变量、实例变量）
//java.lang.class（整个class）
public class User{
//Field
int no;
//Constructor
public User(int no){
this.no = no;
}
//Method
public void setNo(int no){
this.no = no;
}
public int getNo(){
return no;
}
}
获取Class的三种方式
要操作一个类的字节码，首先需要获取到这个类的字节码
package se6;
/*
第一种方式：Class c = Class.forName("完整类名带包名");
*/
public class ReflectTest01 {
public static void main(String[] args) {
/*
Class.forName()
1.静态方法
2.方法的参数是一个字符串
3.字符串需要的是一个完整类名
4.完整类名必须是带有包名。java.lang包也不能省略！
*/
try {
Class c1 = Class.forName("java.lang.String");//c1代表String.class文件，或者说c1代表String类型
Class c2 = Class.forName("java.util.Date");//c2代表Date类型
Class c3 = Class.forName("java.lang.Integer");//c3代表Integer类型
Class c4 = Class.forName("java.lang.System");//c4代表System类型
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
研究：Class.forName()发生了什么
package se6;
/*
注意：如果只希望一个类的静态代码块执行，其他代码一律不执行，可以使用：Class.forName("完整类名");
*/
public class ReflectTest06 {
public static void main(String[] args) {
try {
//Class.forName这个方法的执行会导致：类加载,类加载时，静态代码块执行。
Class.forName("se6.MyClass");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
class MyClass{
//静态代码块在类加载时执行，并且只执行一次
static {
System.out.println("MyClass类的静态代码块执行了！");
}
}
package se6;
import java.util.Date;
//第二种方式：Class C = 对象.getClass();
public class ReflectTest02 {
public static void main(String[] args) {
Class c1 = null;
Class c2 = null;
try {
c1 = Class.forName("java.lang.String");
c2 = Class.forName("java.util.Date");//c2代表Date类型
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
//java中任何一个对象都有一个方法：getClass()
String s = "abc";
Class x = s.getClass();//x代表String.class字节码文件。x代表String类型
System.out.println(c1 == x);//true(== 判断的是对象的内存地址)
Date time = new Date();
Class y = time.getClass();
System.out.println(c2 == y);//true（c2和y两个变量中保存的内存地址都是一样的，都指向方法区中的字节码文件）
}
}
package se6;
import java.util.Date;
//第三种方式：Class c = 任何类型.class;
public class ReflecTest03 {
public static void main(String[] args) {
String s = "abc";
Class x = s.getClass();
//java语言中任何一种类型，包括基本数据类型，他都有.class属性
Class z = String.class;//z代表String类型
Class k = Date.class;//k代表Date类型
Class f = int.class;//f代表int类型
Class e = double.class;//e代表double类型
System.out.println(x == z);//true
}
}
通过反射实例化对象
获取class之后，能干什么?
通过Class的newInstance()方法来实例化对象（调用无参数构造方法实例化对象）
注意：newInstance()方法内部实际上调用了无参数构造方法，必须保证无参构造方法存在
package se6;
import se6.bean.User;
public class ReflectTest04 {
public static void main(String[] args) {
//这是不使用反射机制，创建对象
User user = new User();
System.out.println(user);
try {
//通过反射机制，获取class，通过class来实例化对象
Class c = Class.forName("se6.bean.User");//c代表User类型
//newInstance()这个方法会调用User这个类的无参数构造方法，完成对象的创建
//重点是：newInstance()调用的是无参构造，必须保证无参构造是存在的！
Object obj = c.newInstance();
System.out.println(obj);//se6.bean.User@154617c
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
}
}
}
验证反射机制的灵活性
java代码写一遍，在不改变java源代码的基础上，可以做到不同对象的实例化，非常之灵活。
package se6.bean;
public class User {
public User() {
System.out.println("无参构数造方法！");
}
}
#修改前：className=se6.bean
className=java.util.Date
package se6;
import java.io.FileReader;
import java.util.Properties;
public class ReflectTest05 {
public static void main(String[] args) throws Exception {
//这种方式代码就写死了，只能创建一个User类型的对象
//User user = new User();
//以下代码是灵活的，代码不需要改动，可以修改配置文件，配置文件修改之后，可以创建不同的实例对象
//通过IO流读取class.properties文件
FileReader reader = new FileReader("E:\\学习资料\\老杜Java系列\\Code\\classinfo.properties");
//创建属性类对象Map
Properties pro = new Properties();//key value都是String
//加载
pro.load(reader);
//关闭流
reader.close();
//通过key获取vale
String className = pro.getProperty("className");
System.out.println(className);//se6.bean.User
//通过反射机制实例化对象
Class c = Class.forName(className);
Object obj = c.newInstance();
System.out.println(obj);
/**
* 运行结果：
* java.util.Date
* Fri Nov 27 15:41:34 CST 2020
*/
}
}
研究一下文件路径的问题
以下讲解的这种方式是通用的，当前提是：文件需要在类路径下，才能用这种方式。
注意：最好不要用中文路径，会乱码之类的，这里没办法，以前先用中文名创建了文件夹。。。
package se6;
public class AboutPath {
public static void main(String[] args) throws Exception {
/*
这种方式的路径缺点：移植性差，在IDEA中默认的当前路径是project的根
这个代码假设离开了IDEA，换到了其他位置，可能当前路径就不是project的根了。这时这个路径就无效了
FileReader reader = new FileReader("E:\\学习资料\\老杜Java系列\\Code\\classinfo.properties");
*/
//接下来说一种比较通用的一种路径，即使代码换位置了，这样编写依然是通用的。
//注意：使用以下通用方式的前提是：这个文件必须在类路径下
//什么是类路径？凡是在src下的都是类路径！src是类的根路径
//这种方式是通用的
String path = Thread.currentThread().getContextClassLoader()
.getResource("classinfo2.properties").getPath();
/*
Thread.currentThrea() 当前线程对象
getContextClassLoader() 是线程对象的方法，可以获取到当前线程的类加载器对象
getResource() 【获取资源】这是类加载器对象的方法，当前线程的类加载器默认从类的根路径下加载资源
*/
System.out.println(path);
/*
/E:/%e5%ad%a6%e4%b9%a0%e8%b5%84%e6%96%99/%e8%80%81%e6%9d%9cJava%e7%b3%bb%e5%88%97/Code/out/production/Code/classinfo2.properties
*/
//获取db.properties文件的绝对路径
String path2 = Thread.currentThread().getContextClassLoader()
.getResource("se6/bean/db.properties").getPath();
System.out.println(path2);
/* /E:/%e5%ad%a6%e4%b9%a0%e8%b5%84%e6%96%99/%e8%80%81%e6%9d%9cJava%e7%b3%bb%e5%88%97/Code/out/production/Code/se6/bean/db.properties
*/
}
}
以流的形式返回
package se6;
import java.io.InputStream;
import java.util.Properties;
public class IoPropertiesTest {
public static void main(String[] args) throws Exception{
//获取一个文件的绝对路径！！！
//注意：老是报错可能是因中文路径引起的，以后最好都写英文！！！
/*
String path = Thread.currentThread().getContextClassLoader()
.getResource("asd").getPath();
FileReader reader = new FileReader(path);
*/
//直接以流的形式返回
InputStream reader = Thread.currentThread().getContextClassLoader()
.getResourceAsStream("classinfo.properties");
Properties pro = new Properties();
pro.load(reader);
reader.close();
//通过key获取value
String className = pro.getProperty("className");
System.out.println(className);
}
}
资源绑定器
java.util包下提供了一个资源绑定器，便于获取属性配置文件中的内容、
使用以下这种方式的时候，属性配置文件xxx.properties必须放到类路径下。
#修改前：className=se6.bean
className=fuck!
className=ohhhhhhhhhh~
package se6;
import java.util.ResourceBundle;
public class ResourceBundleTest {
public static void main(String[] args) {
/*
资源绑定器，只能绑定xxx.properties文件。并且这个文件必须在类路径下，文件扩展名也必须是properties。
而且写路径的时候，路径后面的扩展名不能写。
*/
ResourceBundle bundle = ResourceBundle.getBundle("classinfo2");
String className = bundle.getString("className");
System.out.println(className);//fuck!
ResourceBundle bundle2 = ResourceBundle.getBundle("se6/bean/ohhhhh");
String className2 = bundle2.getString("className");
System.out.println(className2);//ohhhhhhhhhh~
}
}
扩展
类加载器概述
专门负责加载类的命令/工具，classLoader
JDK中自带了3个类加载器
- 启动类加载器（父加载器）
- 扩展类加载器（母加载器）
- 应用类加载器
假设有如下代码：
String s = "abc";
代码再开始执行之前，会将需要类全部加载到JVM当中，通过类加载器加载，看到以上代码类加载器会找String.class文件，找到就加载，那么是怎么进行加载的呢？
首先通过“启动类加载器”加载（注意：启动类加载器专门加载：C:\Program Files\Java\jdk1.8.0_151\jre\lib\rt.jar，rt.jar中都是JDK最核心的类库），如果通过“启动类加载器”加载不到的时候，会通过“扩展类加载器”加载（注意：扩展类加载器专门加载：C:\Program Files\Java\jdk1.8.0_151\jre\lib\ext*.jar），如果扩展类加载器中没有加载到，那么会通过应用类加载器加载（注意：应用类加载器专门加载：classpath中的jar包（class文件））。
双亲委派机制
java中为了保证类加载的安全，使用了双亲委派机制。
优先从启动类加载器中加载，这个称为“父”，父无法加载到，再次扩展类加载器中加载，这个称为“母”，双亲委派。如果都加载不到，才会考虑从应用类加载器中加载，直到加载到为止。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
