1、获取class的三种方式
- 第一种：Class c = Class.forName(“完整类名带包名”);
- 第二种：Class c = 对象.getClass();
- 第三种：Class c = 任何类型.class;
public class ReflectTest01 {
public static void main(String[] args) {
/*
Class.forName()
1、静态方法
2、方法的参数是一个字符串。
3、字符串需要的是一个完整类名。
4、完整类名必须带有包名。java.lang包也不能省略。
*/
Class c1 = null;
Class c2 = null;
try {
//第一种方式
c1 = Class.forName("java.lang.String"); // c1代表String.class文件，或者说c1代表String类型。
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();
}
//第二种方式
// 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两个变量中保存的内存地址都是一样的，都指向方法区中的字节码文件。)
// 第三种方式，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
}
}
2、只执行静态代码块
-
如果你只是希望一个类的静态代码块执行，其它代码一律不执行，可以使用:
-
Class.forName(“完整类名”);
-
这个方法的执行会导致类加载，类加载时，静态代码块执行。
-
被执行类
public class MyClass {
// 静态代码块在类加载时执行，并且只执行一次。
static {
System.out.println("MyClass类的静态代码块执行了！");
}
}
- 调用类
public class ReflectTest04 {
public static void main(String[] args) {
try {
// Class.forName()这个方法的执行会导致：类加载。
Class.forName("com.bjpowernode.java.reflect.MyClass");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
3、获取类路径下的绝对路径(通用)
注意：使用以下通用方式的前提是：这个文件必须在类路径下
public class AboutPath {
public static void main(String[] args) throws Exception{
/*
解释：
Thread.currentThread() 当前线程对象
getContextClassLoader() 是线程对象的方法，可以获取到当前线程的类加载器对象。
getResource() 【获取资源】这是类加载器对象的方法，当前线程的类加载器默认从类的根路径下加载资源。
*/
String path = Thread.currentThread().getContextClassLoader()
.getResource("classinfo2.properties").getPath(); // 这种方式获取文件绝对路径是通用的。
System.out.println(path);
// 获取db.properties文件的绝对路径（从类的根路径下作为起点开始）
String path2 = Thread.currentThread().getContextClassLoader()
.getResource("com/wula/java/bean/db.properties").getPath();
System.out.println(path2);
}
}
4、资源绑定器
- java.util包下提供了一个资源绑定器，便于获取属性配置文件中的内容。
- 使用以下这种方式的时候，属性配置文件xxx.properties必须放到类路径下。
public class ResourceBundleTest {
public static void main(String[] args) {
// 资源绑定器，只能绑定xxx.properties文件。并且这个文件必须在类路径下。文件扩展名也必须是properties
// 并且在写路径的时候，路径后面的扩展名不能写。
ResourceBundle bundle = ResourceBundle.getBundle("classinfo2");
//ResourceBundle bundle = ResourceBundle.getBundle("com/wula/java/bean/db");
String className = bundle.getString("className");
System.out.println(className);
}
}
5、JDK自带的类加载器
-
什么是类加载器？
- 专门负责加载类的命令/工具。 ClassLoader
-
JDK中自带了3个类加载器
- 启动类加载器:rt.jar
- 扩展类加载器:ext/*.jar
- 应用类加载器:classpath
-
假设有这样一段代码：
String s = "abc";代码在开始执行之前，会将所需要类全部加载到JVM当中。 通过类加载器加载，看到以上代码类加载器会找String.class 文件，找到就加载，那么是怎么进行加载的呢？ 首先通过“启动类加载器”加载。 注意：启动类加载器专门加载：C:\Program Files\Java\jdk1.8.0_101\jre\lib\rt.jar rt.jar中都是JDK最核心的类库。 如果通过“启动类加载器”加载不到的时候， 会通过"扩展类加载器"加载。 注意：扩展类加载器专门加载：C:\Program Files\Java\jdk1.8.0_101\jre\lib\ext\*.jar 如果“扩展类加载器”没有加载到，那么 会通过“应用类加载器”加载。 注意：应用类加载器专门加载：classpath中的类。 -
java中为了保证类加载的安全，使用了双亲委派机制。
优先从启动类加载器中加载，这个称为“父” “父”无法加载到，再从扩展类加载器中加载， 这个称为“母”。双亲委派。如果都加载不到， 才会考虑从应用类加载器中加载。直到加载到为止。
6、Field 反射属性
Field翻译为字段，其实就是属性/成员
- 实体类
public class Student {
// 4个Field，分别采用了不同的访问控制权限修饰符
private String name; // Field对象
protected int age; // Field对象
boolean sex;
public int no;
public static final double MATH_PI = 3.1415926;
}
- 演示
public class ReflectTest07 {
public static void main(String[] args) throws Exception{
// 我们不使用反射机制，怎么去访问一个对象的属性呢？
Student s = new Student();
// 给属性赋值
s.no = 1111; //三要素：给s对象的no属性赋值1111
//要素1：对象s
//要素2：no属性
//要素3：1111
// 读属性值
// 两个要素：获取s对象的no属性的值。
System.out.println(s.no);
// 使用反射机制，怎么去访问一个对象的属性。（set get）
Class studentClass = Class.forName("com.wula.java.bean.Student");
Object obj = studentClass.newInstance(); // obj就是Student对象。（底层调用无参数构造方法）
// 获取no属性（根据属性的名称来获取Field）
Field noFiled = studentClass.getDeclaredField("no");
// 给obj对象(Student对象)的no属性赋值
/*
虽然使用了反射机制，但是三要素还是缺一不可：
要素1：obj对象
要素2：no属性
要素3：2222值
注意：反射机制让代码复杂了，但是为了一个“灵活”，这也是值得的。
*/
noFiled.set(obj, 22222); // 给obj对象的no属性赋值2222
// 读取属性的值
// 两个要素：获取obj对象的no属性的值。
System.out.println(noFiled.get(obj));
// 可以访问私有的属性吗？
Field nameField = studentClass.getDeclaredField("name");
// 打破封装（反射机制的缺点：打破封装，可能会给不法分子留下机会！！！）
// 这样设置完之后，在外部也是可以访问private的。
nameField.setAccessible(true);
// 给name属性赋值
nameField.set(obj, "jackson");
// 获取name属性的值
System.out.println(nameField.get(obj));
}
}
- 输出
1111
22222
jackson
7、Field反编译
public class ReflectTest06 {
public static void main(String[] args) throws Exception{
// 创建这个是为了拼接字符串。
StringBuilder s = new StringBuilder();
Class studentClass = Class.forName("java.lang.Thread");
s.append(Modifier.toString(studentClass.getModifiers()) + " class " + studentClass.getSimpleName() + " {\n");
Field[] fields = studentClass.getDeclaredFields();
for(Field field : fields){
s.append("\t");
s.append(Modifier.toString(field.getModifiers()));
s.append(" ");
s.append(field.getType().getSimpleName());
s.append(" ");
s.append(field.getName());
s.append(";\n");
}
s.append("}");
System.out.println(s);
}
}
12万+
