注解与反射
寄蜉蝣于天地，渺沧海之一粟
反射就是把java类中的各种成分映射成一个个的Java对象
1. 注解
可以被程序读取的注释
1.1 内置注解
- 栗子：
package com.xxy.test;
//测试学习什么是注解
import java.lang.annotation.*;
import java.util.ArrayList;
import java.util.List;
@SuppressWarnings("all") //抑制编译警告信息,不建议
public class Test01 extends Object{
@Override //重写的注解
public String toString() {
return "Test01{}";
}
@Deprecated //不推荐使用的注解
public static void test() {
System.out.println("djsnfj");
}
public void test1() {
List list = new ArrayList();
}
public static void main(String[] args) {
test();
}
}
1.2 元注解(meta-annotation)
使用@interface自定义注解时，自动继承了java.lang.annotation接口，注解元素必须要有值
- 栗子：
package com.xxy.test;
//测试学习什么是注解
import java.lang.annotation.*;
import java.util.ArrayList;
import java.util.List;
@SuppressWarnings("all") //抑制编译警告信息,不建议
public class Test01 extends Object{
@Override //重写的注解
public String toString() {
return "Test01{}";
}
@Deprecated //不推荐使用的注解
public static void test0() {
System.out.println("djsnfj");
}
//注解可以显示赋值，没有默认值，必须赋值
@MyAnnotation1()
@MyAnnotation2("dh")
public void test1() {
List list = new ArrayList();
}
public static void main(String[] args) {
test0();
}
}
//定义一个注解 meta-annotation
//Documented表示是否将我们的注释生成在JavaDoc中
@Documented
//Inherited表示子类可以继承父类的注解
@Inherited
//Retention表示我们注解什么时候有效 RUNTIME > CLASS > SOURCE
@Retention(RetentionPolicy.RUNTIME)
//Target表示我们可以注释哪些地方
@Target({ElementType.CONSTRUCTOR, ElementType.FIELD, ElementType.LOCAL_VARIABLE, ElementType.METHOD, ElementType.PACKAGE, ElementType.PARAMETER, ElementType.TYPE})
@interface MyAnnotation1 {
//注解的参数
String name() default "";
int age() default 0;
int id() default -1;
String[] schools() default {"什么大学","hello大学"};
}
//Documented表示是否将我们的注释生成在JavaDoc中
@Documented
//Inherited表示子类可以继承父类的注解
@Inherited
//Retention表示我们注解什么时候有效 RUNTIME > CLASS > SOURCE
@Retention(RetentionPolicy.RUNTIME)
//Target表示我们可以注释哪些地方
@Target({ElementType.CONSTRUCTOR, ElementType.FIELD, ElementType.LOCAL_VARIABLE, ElementType.METHOD, ElementType.PACKAGE, ElementType.PARAMETER, ElementType.TYPE})
@interface MyAnnotation2 {
/*String name();*/
//只有一个注解的参数建议用value
String value();
}
1.3 反射操作注解
- 栗子
- 自定义注解一
package com.xxy.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface TableORM {
String value();
}
- 自定义注解二
package com.xxy.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Field {
String columnName() default "";
String type() default "";
int length() default 0;
}
- 反射操作注解
package com.xxy.test;
import com.xxy.annotation.TableORM;
import java.lang.annotation.Annotation;
import java.lang.reflect.Field;
//通过反射获取注解
public class Test08 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
Class c1 = Class.forName("com.xxy.entity.User");
Annotation[] annotations = c1.getAnnotations();
for (Annotation annotation : annotations) {
System.out.println(annotation);
}
//获取注解value的值
TableORM annotation = (TableORM) c1.getAnnotation(TableORM.class);
String value = annotation.value();
System.out.println(value);
//获取类指定注解
Field name = c1.getDeclaredField("name");
com.xxy.annotation.Field annotation1 = name.getAnnotation(com.xxy.annotation.Field.class);
System.out.println(annotation1.columnName());
System.out.println(annotation1.type());
System.out.println(annotation1.length());
}
}
2. 反射机制
Class类是反射机制的根源，可以通过Object类中所提供的方法获取一个Class实例，
- 动态语言
在运行时可以改变结构的语言，例如JavaScript，PHP，Python
- 静态语言
运行时不可以改变结构，例如Java【准动态语言，可以通过反射改变结构】，C，C++
3. Class类对象实例化
在运行期间，一个类，只有一个Class对象产生
-
通过Class.forName()方法【最常见】
-
通过Object的getClass()方法
-
通过“类.class"的形式
-
栗子
package com.xxy.test;
import com.xxy.entity.User;
import java.lang.annotation.ElementType;
public class Test02 {
public static void main(String[] args) throws ClassNotFoundException {
User user = new User();
System.out.println(user);
//方式一：通过对象.getClass获得
Class c1 = user.getClass();
System.out.println(c1.hashCode());
//方式二：通过反射forName获取类的class对象
Class c2 = Class.forName("com.xxy.entity.User");
System.out.println(c2.hashCode());
//方式三：通过类名.class获得
Class c3 = User.class;
System.out.println(c3.hashCode());
//基本内置类型的包装类都有一个Type属性
Class type = Integer.TYPE;
System.out.println(type);
//获得父类类型
Class superclass = c2.getSuperclass();
System.out.println(superclass);
Class c4 = Object.class; //类
Class c5 = Comparable.class;//接口
Class c6 = String[].class;//一维数组
Class c7 = int[][].class;//二维数组
Class c8 = Override.class;//注解
Class c9 = ElementType.class;//枚举
Class c10 = Integer.class;//基本数据类型
Class c11 = void.class;//空类型
Class c12 = Class.class;//Class
System.out.println(c4 );
System.out.println(c5 );
System.out.println(c6 );
System.out.println(c7 );
System.out.println(c8 );
System.out.println(c9 );
System.out.println(c10);
System.out.println(c11);
System.out.println(c12);
}
}
4. 对象实例化
创建一个类的实例时（new,反射，浅克隆，反序列化(深克隆)）
4.1 创建运行时类的对象
- 栗子：
package com.xxy.test;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
//获取类的信息
public class Test05 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException {
Class c1 = Class.forName("com.xxy.entity.User");
//获得类名
System.out.println(c1.getName());//获取包名+类名
System.out.println(c1.getSimpleName());//获取包名
System.out.println("-------------------");
//获得类的属性,私有不能找到
Field[] fields = c1.getFields();
for (Field field : fields) {
System.out.println(field);
}
//可以找到私有属性的值
Field[] declaredFields = c1.getDeclaredFields();
for (Field declaredField : declaredFields) {
System.out.println(declaredField);
}
//获取指定属性的值
Field name = c1.getDeclaredField("name");
System.out.println(name);
System.out.println("-------------------");
//获取类的public方法
Method[] methods = c1.getMethods();
for (Method method : methods) {
System.out.println(method);
}
//获取类的所有方法
Method[] declaredMethods = c1.getDeclaredMethods();
for (Method declaredMethod : declaredMethods) {
System.out.println(declaredMethod);
}
//获取指定方法,需要考虑重载
Method getAge = c1.getMethod("getAge",null);
Method setAge = c1.getMethod("setAge", int.class);
System.out.println(setAge);
System.out.println(getAge);
System.out.println("-------------------");
//获取指定构造器
Constructor[] constructors = c1.getConstructors();
for (Constructor constructor : constructors) {
System.out.println(constructor);
}
Constructor[] declaredConstructors = c1.getDeclaredConstructors();
for (Constructor declaredConstructor : declaredConstructors) {
System.out.println("#" + declaredConstructor);
}
//获取指定构造器
Constructor declaredConstructor = c1.getDeclaredConstructor(int.class, String.class, int.class);
System.out.println("指定：" + declaredConstructor);
}
}
4.2 通过反射动态创建对象
- 栗子
package com.xxy.test;
import com.xxy.entity.User;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class Test06 {
public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
Class c1 = Class.forName("com.xxy.entity.User");
//无参构造
/* User user = (User) c1.newInstance();
System.out.println(user);*/
//有参构造
Constructor declaredConstructor = c1.getDeclaredConstructor(int.class, String.class, int.class);
User user1 = (User) declaredConstructor.newInstance(11, "djhf", 54);
System.out.println(user1);
//通过反射调用普通方法
Method setAge = c1.getDeclaredMethod("setAge", int.class);
//invoke 激活方法的值
setAge.invoke(user1,77);
System.out.println(user1.getAge());
//通过反射操作属性
System.out.println("________________");
Field name = c1.getDeclaredField("name");
//关闭访问权限，设置可访问
name.setAccessible(true);
name.set(user1,"aaa");
System.out.println(user1.getName());
System.out.println(user1);
}
}
4.3 性能问题
普通方法（new） > 设置可访问 > 不设置可访问
类.class > Class.forName("") > getClass()
4.4 反射获取泛型
- 栗子
package com.xxy.test;
import com.xxy.entity.User;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.List;
import java.util.Map;
//通过反射获取泛型
public class Test07 {
public void test01(Map<String, User> map, List<User> list) {
System.out.println("test01");
}
public Map<String,User> test02() {
System.out.println("test02");
return null;
}
public static void main(String[] args) throws NoSuchMethodException {
Method test01 = Test07.class.getMethod("test01", Map.class, List.class);
Type[] genericParameterTypes = test01.getGenericParameterTypes();
for (Type genericParameterType : genericParameterTypes) {
System.out.println("#" + genericParameterType);
if (genericParameterType instanceof ParameterizedType) {//如果是参数化类型，获取真实的参数类型
Type[] actualTypeArguments = ((ParameterizedType) genericParameterType).getActualTypeArguments();
for (Type actualTypeArgument : actualTypeArguments) {
System.out.println(actualTypeArgument);
}
}
}
}
}
5. ClassLoader类加载器
5.1 类的加载过程
- 栗子
package com.xxy.test;
public class Test03 {
public static void main(String[] args) {
A a = new A();
System.out.println(A.m);
/**
* 1. 加载到内存，会产生一个类对应class对象
* 2. 连接，连接后m=0
* 3. 初始化
* <clinti>() {
* System.out.println("A类静态代码初始化");
* m = 200;
* m = 100;
* }
*/
}
}
class A {
static {
System.out.println("A类静态代码初始化");
m = 200;
}
static int m = 100;
/**
* 方法区里面，
* m=200
* m=100
*/
public A() {
System.out.println("A类的无参构造");
}
}
5.2 类初始化
- 类的主动引用
- 先初始化main()方法所在的类
- new一个类的对象
- 调用静态成员（除了final常量）和静态方法
- 使用java.lang.reflect包的方法对类进行反射调用
- 初始化一个类时，如果父类没有被初始化，则会先初始化父类
- 类的被动引用
- 当访问一个静态域时，只有真正声明这个域的类才会被初始化
- 通过数组定义类引用，不会触发此类的初始化
- 引用常量不会触发此类的初始化（常量池）
5.3 类加载器的作用
- BootStrap【根加载器，系统类加载器】
由C++语言编写，主要目的是加载Java底层系统提供的核心类库
- ExtensionsClassloader【平台类加载器】
进行模块加载
- APPClassloader【应用程序类加载器】
加载CLASSPATH所指定的类文件或者JAR文件
-
自定义加载器【远程服务加载、数据库加载】
-
栗子
package com.xxy.test;
public class Test04 {
public static void main(String[] args) throws ClassNotFoundException {
//获取系统类加载器
ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
System.out.println(systemClassLoader);
//获取系统加载器的父类加载器-->扩展类加载器
ClassLoader parent = systemClassLoader.getParent();
System.out.println(parent);
//获取扩展类加载器的父类加载器-->根加载器
ClassLoader parent1 = parent.getParent();
System.out.println(parent1);
//测试当前的类是哪个加载器加载的
ClassLoader classLoader = Class.forName("com.xxy.test.Test04").getClassLoader();
System.out.println(classLoader);
//测试jdk内置的类是谁加载的
ClassLoader classLoader1 = Class.forName("java.lang.Object").getClassLoader();
System.out.println(classLoader1);
//获取系统类加载器可以加载的路径
System.out.println(System.getProperty("java.class.path"));
//双亲委派机制：向上找包，找不到就用自己的包，安全性
/**
* D:\install\java\jdk\jre\lib\charsets.jar;
* D:\install\java\jdk\jre\lib\deploy.jar;
* D:\install\java\jdk\jre\lib\ext\access-bridge-64.jar;
* D:\install\java\jdk\jre\lib\ext\cldrdata.jar;
* D:\install\java\jdk\jre\lib\ext\dnsns.jar;
* D:\install\java\jdk\jre\lib\ext\jaccess.jar;
* D:\install\java\jdk\jre\lib\ext\jfxrt.jar;
* D:\install\java\jdk\jre\lib\ext\localedata.jar;
* D:\install\java\jdk\jre\lib\ext\nashorn.jar;
* D:\install\java\jdk\jre\lib\ext\sunec.jar;
* D:\install\java\jdk\jre\lib\ext\sunjce_provider.jar;
* D:\install\java\jdk\jre\lib\ext\sunmscapi.jar;
* D:\install\java\jdk\jre\lib\ext\sunpkcs11.jar;
* D:\install\java\jdk\jre\lib\ext\zipfs.jar;
* D:\install\java\jdk\jre\lib\javaws.jar;
* D:\install\java\jdk\jre\lib\jce.jar;
* D:\install\java\jdk\jre\lib\jfr.jar;
* D:\install\java\jdk\jre\lib\jfxswt.jar;
* D:\install\java\jdk\jre\lib\jsse.jar;
* D:\install\java\jdk\jre\lib\management-agent.jar;
* D:\install\java\jdk\jre\lib\plugin.jar;
* D:\install\java\jdk\jre\lib\resources.jar;
* D:\install\java\jdk\jre\lib\rt.jar;
* D:\JavaWork\reflex\out\production\reflex;
* D:\install\IDEA\IntelliJ IDEA 2019.1\lib\idea_rt.jar
*/
}
}
6. 总结
本次总结了注解和反射的基础，里面如果有错误或者建议，欢迎评论区指出。
扫一扫
890
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
