1. 反射机制
作用:
通过Java语言中的反射机制可以操作字节码文件(读写);通过反射机制可以操作代码片段(class文件)
包:
反射机制的相关类在java.lang.reflect.*;包下
相关重要的类:
java.lang.Class:代表整个字节码,代表一个类型,代表整个类
java.lang.reflect.Method:代表字节码中的方法字节码;类中的方法
java.lang.reflect.Constructor:代表字节码中的构造方法字节码;类中的构造方法
java.lang.reflect.Fileld:代表字节码中的属性字节码;类中的成员变量
2. 获取Class
操作一个类的字节码,首先要获取到这个类的字节码
通过三种方式获取到java.lang.Class实例:
- Class c = Class.forname(“完整类名带包名”);
- Class c = 对象.getClass();
- Class c = 任何类型.class;
【示例】获取Class
import java.util.Date;
public class ReflectTest01 {
public static void main(String[] args) {
/**
* Class.forName():静态方法;参数是一个字符串;
* 字符串需要是一个完整的类名且必须带有包名,java.lang包也不能省略
*/
Class c1 = null;
try {
c1 = Class.forName("java.lang.String"); //c1代表String.class文件,或者说代表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) {
throw new RuntimeException(e);
}
//java中任何一个对象都有一个方法:getClass()
String s = "abc";
Class x = s.getClass(); //x代表String.class字节码文件,x代表String类型
System.out.println(c1 == x); //true.(==判断的是对象的内存地址)
//java语言中的任何一种类型,包括基本数据类型都有.class属性
Class z = String.class; //z代表String类型
Class k = Date.class;
Class f = int.class;
Class e = double.class;
System.out.println(x == z); //true
}
}
注意:字节码文件装载到JVM中的时候只装载一份
【示例】获取到Class后,通过Class的newInstance( )方法来实例化对象
User类
package com.bean;
public class User {
public User() {
//System.out.println("无参构造方法!");
}
}
Test:
package com.test;
import com.bean.User;
/**
* 获取到Class后,通过Class的newInstance()方法来实例化对象
* 注意:newInstance()调用的是无参构造,必须保证无参构造方法的存在
*/
public class ReflectTest02 {
public static void main(String[] args) {
//不使用反射机制,创建对象
User user = new User();
System.out.println(user);
//使用反射机制,创建对象
try {
//通过反射机制,获取Class,通过Class来实例化对象
Class c = Class.forName("com.bean.User");
//newInstance()方法会调用User类的无参构造方法,完成对象的创建
//重点:newInstance()调用的是无参构造,必须保证无参构造方法的存在
Object obj = c.newInstance();
System.out.println(obj);
} catch (ClassNotFoundException e) {
throw new RuntimeException(e);
} catch (InstantiationException e) {
throw new RuntimeException(e);
} catch (IllegalAccessException e) {
throw new RuntimeException(e);
}
}
}
【示例】验证反射机制灵活性
java代码只写一遍,在不改变javadiamante的基础上,可以做到不同对象的实例化,非常灵活。(符合OCP开闭原则:对扩展开放,对修改关闭。)
新建一个classinfo.properties文件
className=com.test.bean //java.util.Date
Test:
package com.test;
import java.io.FileReader;
import java.util.Properties;
/**
* 验证反射机制灵活性
*/
public class ReflectTest03 {
public static void main(String[] args) throws Exception {
//这种方式代码就写死了,只能创建一个User类对象
//User user = new User();
//以下代码是灵活的,代码不需要改动,可以修改配置文件,修改后,可以创建出不同的实例对象
//通过IO流读取classinfo.properties文件
FileReader fr = new FileReader("classinfo.properties");
//创建属性类对象Map
Properties pro = new Properties(); //key value都是String
//加载
pro.load(fr);
//关闭流
fr.close();
//通过key获取value
String className = pro.getProperty("className");
//System.out.println(className); //com.bean.User
//通过反射机制实例化对象
Class c = Class.forName(className);
Object obj = c.newInstance();
System.out.println(obj); //com.bean.User@4554617c
}
}
注意:如果只希望一个类的静态代码块执行,其他代码一律不执行,可以使用Class.forName(“完整类名”); 这个方法执行会导致类加载,类加载时,静态代码块执行。
【示例】Class.forName()
MyClass:
public class MyClass {
//静态代码块在类加载时执行,并且只执行一次
static {
System.out.println("MyClass类静态代码块执行!!");
}
}
Test:
/**
* Class.forName()
*/
public class ReflectTest04 {
public static void main(String[] args) {
try {
//Class.forName()的执行会导致类加载;
Class.forName("com.test.MyClass");
} catch (ClassNotFoundException e) {
throw new RuntimeException(e);
}
}
}
3. 路径问题
【示例】获取类路径下文件的绝对路径
注意:使用以下通用方法的前提是:这个文件必须在类路径下
/**
* 获取类路径下文件的绝对路径
*/
public class AboutPath {
public static void main(String[] args) throws Exception {
//这种方式的路径缺点:移植性差,在IDEA中默认的额当前路径时project的根
//这段代码离开IDEA放到其他位置,当前路径可能就不是project的根,这个路径就无效了
//FileReader fr = new FileReader("classinfo2.properties");
//注意:使用以下通用方法的前提是:这个文件必须在类路径下
//什么是类路径下?凡是在src下的都是类路径下,src是类的根路径
/**
* 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/bean/db.properties").getPath();
System.out.println(path2);
}
}
【示例】以流的形式直接返回
package com.test;
import java.io.InputStream;
import java.util.Properties;
public class IOporpertiesTest {
public static void main(String[] args) throws Exception {
//获取一个文件的句对路径
/*String path = Thread.currentThread().getContextClassLoader()
.getResource("classinfo2.properties").getPath();
FileReader fr = new FileReader(path);*/
//直接以流的形式
InputStream fr = Thread.currentThread().getContextClassLoader()
.getResourceAsStream("classinfo2.properties");
Properties pro = new Properties();
pro.load(fr);
fr.close();
String className = pro.getProperty("className");
System.out.println(className);
}
}
【示例】资源绑定器
java.util包下提供了一个资源绑定器便于获取属性配置文件中的内容,使用这种方式的时候,属性配置文件xxx.properties必须在类路径下
package com.test;
import java.util.ResourceBundle;
/**
* java.util包下提供了一个资源绑定器便于获取属性配置文件中的内容
* 使用以下这种方式的时候,属性配置文件xxx.properties必须在类路径下
*/
public class ResourceBundleTest {
public static void main(String[] args) {
//资源绑定器只能绑定xxx.porperties文件且这个文件必须咋类路径下
//注意:写路径的时候,路径后面的扩展名不能写
//ResourceBundle bundle = ResourceBundle.getBundle("classinfo2");
ResourceBundle bundle = ResourceBundle.getBundle("com/bean/db");
String className = bundle.getString("className");
System.out.println(className);
}
}
4. 类加载器(了解)
专门负责加载类的命令/工具ClassLoader
JDK中自带了3个类加载器:启动类加载器、扩展类加载器、应用类加载器
例如:有一段代码:String = “abc”;
代码在开始执行之前,会将所需要类全部加载到JVM当中。通过类加载器加载,看到以上代码类加载器会找string. class文件,找到就加载,
- 首先通过"启动类加载器”加载。
注意: 启动类加载器专门加载:Java\jdk\jre\lib\rt.jar rt.jar中都是JDK最核心的类库- 如果通过“启动类加载器”加载不到的时候,会通过“扩展类加载器”加载
注意: 扩展类加载器专门加载:Java\jdk\jre\lib\ext*.jar- 如果通过“扩展类加载器”也没有加载到,那么会通过“应用类加载器”加载
注意: 应用类加载器专门加载:classpath中的jar包(class文件)
java中为了保证类加载的安全,使用了双亲委派机制。
优先从启动类加载器中加载,这个称为“父”,“父”无法加载到,再从扩展类加载器中加载,这个称为“母”
双亲委派,如果都加载不到才会考虑从应用类加载器中加载,直到加载到为止。
5. 获取Field
【示例】获取Field
Student:
package com.bean;
//反射属性Field
public class Student {
public int no; //field对象
private String name;
protected int age;
boolean sex;
public static final double MATH_PI = 3.14;
}
Test类:
package com.test;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
/**
* 反射Student类中的所有Field
*/
public class ReflectTest05 {
public static void main(String[] args) throws Exception {
//获取整个类
Class studentClass = Class.forName("com.bean.Student");
String className = studentClass.getName();
System.out.println("完整类名:"+className);
String simpleName = studentClass.getSimpleName();
System.out.println("简类名:"+simpleName);
System.out.println("================");
//获取类中所有的public修饰的Field
Field[] fields = studentClass.getFields();
System.out.println(fields.length); //1
//取出这个Filed
Field f = fields[0];
String fieldName = f.getName();
System.out.println(fieldName); //no
System.out.println("================");
//获取所有的Field
Field[] fs = studentClass.getDeclaredFields();
System.out.println(fs.length); //4
//遍历
for (Field field:fs) {
//获取属性的修饰符列表
int i = field.getModifiers(); //返回的修饰符是int,是修饰符的代号
String modifierSting = Modifier.toString(i);
System.out.print(modifierSting+"\t");
//获取属性的类型
Class fieldType = field.getType();
//String fName = fieldType.getName();
String fName = fieldType.getSimpleName();
System.out.print(fName+"\t");
//获取属性的名字
System.out.println(field.getName());
}
}
}
【示例】 通过反射机制,反编译一个类的属性Field
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
/**
* 通过反射机制,反编译一个类的属性Field
*/
public class ReflectTest06 {
public static void main(String[] args) throws Exception{
//拼接字符串
StringBuilder sb = new StringBuilder();
Class studentClass = Class.forName("com.bean.Student");
sb.append(Modifier.toString(studentClass.getModifiers())+" class "+ studentClass.getSimpleName() +" {\n");
Field[] fields = studentClass.getDeclaredFields();
for (Field field:fields) {
sb.append("\t");
sb.append(Modifier.toString(field.getModifiers()));
sb.append(" ");
sb.append(field.getType().getSimpleName());
sb.append(" ");
sb.append(field.getName());
sb.append(";\n");
}
sb.append("}");
System.out.println(sb);
}
}
【示例】通过反射机制访问对象属性
import java.lang.reflect.Field;
/**
* 通过反射机制访问对象属性
* 给属性赋值set;获取属性的值get
*/
public class ReflectTest07 {
public static void main(String[] args) throws Exception{
/*
Student s = new Student();
s.no = 123;
赋值三要素:对象s、属性no、值123
*/
//反射机制让代码复杂了,但是更加灵活
Class studentClass = Class.forName("com.bean.Student");
Object obj = studentClass.newInstance(); //obj就是Student对象(底层调用无参构造方法)
//获取no属性(根据属性的名称来获取Field)
Field noField = studentClass.getDeclaredField("no");
//给obj对象的no属性赋值(也是赋值三要素,对象、属性、值)
noField.set(obj,123); //给obj对象的no属性赋值123
//获取属性的值
System.out.println(noField.get(obj));
//访问私有属性
Field nameField = studentClass.getDeclaredField("name");
//打破封装(反射机制的缺点,打破封装可能给不法分子留下机会)
nameField.setAccessible(true);
nameField.set(obj,"zhangsan");
System.out.println(nameField.get(obj));
}
}
6. 反射Method
【示例】可变长度参数
语法:类型…
注意:
- 可变长度参数要求参数个数是0~N个
- 可变长度参数在参数列表中必须在最后一个位置,而且只能有一个
- 可变参数长度可以当作一个数组
package com.test;
/**
* 可变长度参数
*/
public class ArgsTest {
public static void main(String[] args) {
m();
m(1);
m(1,2);
//编译报错
/*m("a");*/
m3("abc","def","xyz");
String[] strs = {"aa","bb","cc"};
m3(strs);
m3(new String[]{"a","b","c"});
}
public static void m(int...args){
System.out.println("m方法执行了!!");
}
/*public static void m2(int...args1,String...args2){}*/
public static void m3(String...args){
//args有length属性,说明是一个数组
for (int i = 0; i < args.length; i++) {
System.out.println(args[i]);
}
}
}
【示例】通过反射机制调用方法(重点)
import com.service.UserService;
import java.lang.reflect.Method;
/**
* 通过反射机制调用方法(重点)
*/
public class ReflectTest10 {
public static void main(String[] args) throws Exception{
//不使用反射机制调用
UserService userService = new UserService();
boolean loginSuccess = userService.login("admin","123");
System.out.println(loginSuccess);
//使用反射机制调用
Class userServiceClass = Class.forName("com.service.UserService");
//创建对象
Object obj = userServiceClass.newInstance();
//获取Method
Method loginMethod = userServiceClass.getDeclaredMethod("login", String.class, String.class);
//调用方法:对象,方法名,实参列表,返回值
Object retValue = loginMethod.invoke(obj,"admin","123");
System.out.println(retValue);
}
}
【示例】通过反射机制调用构造方法实例化对象
package com.test;
import com.bean.Vip;
import java.lang.reflect.Constructor;
/**
* 通过反射机制调用构造方法实例化对象
*/
public class ReflectTest12 {
public static void main(String[] args) throws Exception{
//不使用反射机制
Vip v1 = new Vip();
Vip v2 = new Vip(001,"张三");
//使用反射机制
Class c = Class.forName("com.bean.Vip");
//调用无参构造方法
Object obj = c.newInstance();
System.out.println(obj);
//调用有参构造方法
//1. 先获取到有参构造方法
Constructor con = c.getDeclaredConstructor(int.class,String.class);
//2. 调用构造方法new对象
Object newObj = con.newInstance(001,"zhang");
System.out.println(newObj);
/*
//获取无参构造方法
Constructor con2 = c.getDeclaredConstructor();
Object newObj2 = con2.newInstance();
System.out.println(newObj2);
*/
}
}
【示例】获取类的父类以及接口
/**
* 获取类的父类以及接口
*/
public class ReflectTest13 {
public static void main(String[] args) throws Exception{
//String
Class stingClass = Class.forName("java.lang.String");
//获取String的父类
Class superClass = stingClass.getSuperclass();
System.out.println(superClass.getName());
//获取String实现的接口
Class[] interfaces = stingClass.getInterfaces();
for (Class in:interfaces) {
System.out.println(in.getName());
}
}
}
7. 注解
定义:
- 注解是一种引用数据类型,编译后生成的是.class文件
- 语法格式:
[修饰符列表] @interface 注释类型名{
}
使用:
- 注解使用时的语法格式:@注解类型名
- 注解可以出现在类上、属性上、方法上、变量上等…还可以出现在注解上
JDK内置注解:
元注解:
用来标注“注解类型”的“注解”
常见的元注解:@Target,@Retention
@Target:用来标注“被标注的注解”可以出现在哪些位置上。
@Target(ElementType.METHOD):表示被标注的注解只能出现在方法上
@Retention:用来标注“被标注的注解”最终保存在什么位置
@Retention(RetentionPolicy.SOURCE):表示该注解只被保留在java源文件中
@Retention(RetentionPolicy.CLASS):表示该注解被保留在class文件中
@Retention(RetentionPolicy.RUNTIME):表示该注解被保留在class文件中,并且可以被反射机制所读取
@Retention源代码
//元注解
public @interface Retention {
//属性
RetentionPolicy value();
}
// RetentionPolicy的源代码
public enum RetentionPolicy {
SOURCE,
CLASS,
RUNTIME
}
【示例】通过反射机制获取注解对象属性的值
package com.test.annotation6;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface MyAnnotation {
String username();
String password();
}
package com.test.annotation6;
import java.lang.reflect.Method;
public class MyAnnotationTest {
@MyAnnotation(username = "admin",password = "123")
public void doSome(){
}
public static void main(String[] args) throws Exception{
//获取MyAnnotationTest的doSome方法上的注解信息
Class c = Class.forName("com.test.annotation6.MyAnnotationTest");
//获取doSome方法
Method dsm = c.getDeclaredMethod("doSome");
//判断该方法上是否存在注解
if (dsm.isAnnotationPresent(MyAnnotation.class)){
MyAnnotation myAnnotation = dsm.getAnnotation(MyAnnotation.class);
System.out.println(myAnnotation.username());
System.out.println(myAnnotation.password());
}
}
}