版权声明：自然 https://blog.csdn.net/qq_38943922/article/details/87477051
package zr.test;
import java.io.InputStream;
import java.lang.annotation.Annotation;
import java.lang.reflect.AnnotatedType;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Type;
import java.lang.reflect.TypeVariable;
import java.net.URL;
import java.security.ProtectionDomain;
import study.core.Reflex;
import study.sqlite3.main.User;
import study.sqlite3.main.User.A;
import zr.annotation.Run;
/**
* java 反射
* @author Administrator
*
*/
public class Javareflex {
public static void main(String[] args) throws Exception {
//----理解class类
@SuppressWarnings("deprecation")
User user = new User();
user.setUserCode("hello");
System.out.println(user.getClass()==User.class);
Class<? extends User> clazz1 = user.getClass();
//转型
// asSubclass 向上转型
Reflex reflex = clazz1.asSubclass(Reflex.class).newInstance();
reflex=clazz1.newInstance();
Object properties = reflex.properties();
// Class<? extends List> asSubclass = clazz1.asSubclass(List.class);
// --判断父类
// cast 向下转型
Object o=user;
User cast = user.getClass().cast(o);//
//desiredAssertionStatus 断言状态
boolean desiredAssertionStatus = clazz1.desiredAssertionStatus();
//通过字符串获取字节码对象
//forName
Class<?> user1 = Class.forName(user.getClass().getName());
System.out.println(user1);
// getAnnotatedInterfaces 注解
boolean annotationPresent = clazz1.isAnnotationPresent(Run.class);
AnnotatedType[] annotatedInterfaces = clazz1.getAnnotatedInterfaces();
AnnotatedType annotatedSuperclass = clazz1.getAnnotatedSuperclass();
Run annotation = clazz1.getAnnotation(Run.class);
Annotation[] annotations = clazz1.getAnnotations();
Run[] annotationsByType = clazz1.getAnnotationsByType(Run.class);
Run declaredAnnotation = clazz1.getDeclaredAnnotation(Run.class);
Annotation[] declaredAnnotations = clazz1.getDeclaredAnnotations();
Run[] declaredAnnotationsByType = clazz1.getDeclaredAnnotationsByType(Run.class);
boolean annotation2 = clazz1.isAnnotation();
// --运行对象
// 返回由Java语言规范定义的基础类的规范名称。
String canonicalName = clazz1.getCanonicalName();
//内部类
Class<?>[] classes = clazz1.getClasses();
Class<?>[] declaredClasses = clazz1.getDeclaredClasses();
//通过内部类获取外部类
Class<?> enclosingClass = A.class.getEnclosingClass();
//通过匿名内部类获取当前所在构造方法
Constructor<?> enclosingConstructor = clazz1.getEnclosingConstructor();
Object properties1 = user.properties("reflex");
Class<? extends Object> class1 = properties1.getClass();
Constructor<?> enclosingConstructor2 = class1.getEnclosingConstructor();
//通过匿名内部类获取当前所在方法
user.test();
Object properties2 = user.properties("reflex");
Class<? extends Object> class11 = properties2.getClass();
Method enclosingMethod = class11.getEnclosingMethod();
//判断匿名类
boolean anonymousClass = class11.isAnonymousClass();
//判断局部类
class Local{}
boolean localClass = Local.class.isLocalClass();
//判断成员类
boolean memberClass = A.class.isMemberClass();
// getClassLoader()
// 获取该类的类装载器。
// 实现java对象动态性
// JAVA类装载方式，有两种:
// 1.隐式装载， 程序在运行过程中当碰到通过new 等方式生成对象时，隐式调用类装载器加载对应的类到jvm中。
// 2.显式装载， 通过class.forname()等方法，显式加载需要的类
// java类装载器
// JDK 默认提供了如下几种ClassLoader
// Bootstrp loader
// Bootstrp加载器是用C++语言写的，它是在Java虚拟机启动后初始化的，它主要负责加载%JAVA_HOME%/jre/lib,
// -Xbootclasspath参数指定的路径以及%JAVA_HOME%/jre/classes中的类。
// ExtClassLoader
// Bootstrp loader加载ExtClassLoader,并且将ExtClassLoader的父加载器设置为Bootstrp
// loader.ExtClassLoader是用Java写的，具体来说就是 sun.misc.Launcher$ExtClassLoader，
// ExtClassLoader主要加载%JAVA_HOME%/jre/lib/ext，此路径下的所有classes目录以及java.ext.dirs
// 系统变量指定的路径中类库。
// AppClassLoader
// Bootstrp loader加载完ExtClassLoader后，就会加载AppClassLoader,
// 并且将AppClassLoader的父加载器指定为 ExtClassLoader。AppClassLoader也是用Java写成的，
// 它的实现类是 sun.misc.Launcher$AppClassLoader，
// 另外我们知道ClassLoader中有个getSystemClassLoader方法,
// 此方法返回的正是AppclassLoader.AppClassLoader主要负责加载classpath所指定的位置的类或者是jar文档，
// 它也是Java程序默认的类加载器。
// 类加载器之间是如何协调工作的
// 前面说了，java中有三个类加载器，问题就来了，碰到一个类需要加载时，它们之间是如何协调工作的，
// 即java是如何区分一个类该由哪个类加载器来完成呢。 在这里java采用了委托模型机制，这个机制简单来讲，
// 就是“类装载器有载入类的需求时，会先请示其Parent使用其搜索路径帮忙载入，如果Parent 找不到,
// 那么才由自己依照自己的搜索路径搜索类”
//--Service Provider Interface 服务提供
ClassLoader classLoader = user.getClass().getClassLoader();
//获取父类装载器
ClassLoader parent = classLoader.getParent();
ClassLoader parent2 = parent.getParent();
InputStream resourceAsStream = classLoader.getResourceAsStream("read.txt");
//类文件加密解密
// getComponentType()
// 如果当前类表示一个数组，则返回表示该数组组件的Class对象，否则返回null。
System.out.println(new String("H").getClass().getComponentType());
System.out.println(new String[] {"90","80","70"}.getClass().getComponentType());
// ----数组判断
//构造函数
// getConstructor(Class[])
// 返回当前Class对象表示的类的指定的公有构造子对象。
Constructor<? extends User> constructor = user.getClass().getConstructor(Integer.class,String.class);
User user2 = constructor.newInstance(90,"自然");
System.out.println(user2);
// getConstructors()
// 返回当前Class对象表示的类的所有公有构造子对象数组。
@SuppressWarnings("unused")
Constructor<?>[] constructors = user.getClass().getConstructors();
// getDeclaredConstructor(Class[])
// 返回当前Class对象表示的类的指定已说明的一个构造子对象。
Constructor<? extends User> constructor2 = user.getClass().getDeclaredConstructor(Integer.class,String.class,String.class);
constructor2.setAccessible(true);
User user3 = constructor2.newInstance(90,"自然","指针");
//-----通过私有构造函数创建对象
// getDeclaredConstructors()
// 返回当前Class对象表示的类的所有已说明的构造子对象数组。
Class<? extends User> clazz = user.getClass();
Constructor<?>[] constructors2 = clazz.getDeclaredConstructors();
AnnotatedType annotatedReceiverType = constructor2.getAnnotatedReceiverType();
Class<? extends User> declaringClass = constructor2.getDeclaringClass();
// --获取对象下所有构造函数
// 字段
// getDeclaredField(String)
// 返回当前Class对象表示的类或接口的指定已说明的一个域对象。
Class<? extends User> clazz3 = user3.getClass();
Field field = clazz3.getDeclaredField("userId");
// getDeclaredFields()
// 返回当前Class对象表示的类或接口的所有已说明的域对象数组。
Field[] fields = clazz3.getDeclaredFields();
//--获取所有字段
// getDeclaredMethod(String,Class[])
// 返回当前Class对象表示的类或接口的指定已说明的一个方法对象。
// getField(String)
// 返回当前Class对象表示的类或接口的指定的公有成员域对象。
// Field field2 = clazz3.getField("userId");
// --判断字段访问权限
// getFields()
// 返回当前Class对象表示的类或接口的所有可访问的公有域对象数组。
Field[] fields2 = clazz3.getFields();
//方法
Method method = clazz3.getDeclaredMethod("getUserId",Integer.class);
Object invoke = method.invoke(user3,0);
// getMethod(String,Class[])
// 返回当前Class对象表示的类或接口的指定的公有成员方法对象。
Method method2 = clazz3.getMethod("getUserId");
Object invoke2 = method2.invoke(user3);
// getMethods()
// 返回当前Class对象表示的类或接口的所有公有成员方法对象数组，包括已声明的和从父类继承的方法。
Method[] methods = clazz3.getMethods();
//枚举
User[] enumConstants = clazz.getEnumConstants();
boolean enum1 = clazz.isEnum();
//接口
// getInterfaces()
// 返回当前对象表示的类或接口实现的接口。
Class<?>[] interfaces = clazz3.getInterfaces();
Type[] genericInterfaces = clazz3.getGenericInterfaces();
// isInterface()
// 判定指定的Class对象是否表示一个接口类型。
boolean interface1 = clazz3.isInterface();
//超类
Class<?> superclass2 = clazz3.getSuperclass();
Type genericSuperclass = clazz3.getGenericSuperclass();
boolean assignableFrom = clazz3.isAssignableFrom(Object.class);
//修饰权限
// getModifiers()
// 返回该类或接口的Java语言修改器代码。
int modifiers = clazz.getModifiers();
// getName()
// 返回Class对象表示的类型(类、接口、数组或基类型)的完整路径名字符串。
String name = clazz3.getName();
String simpleName = clazz3.getSimpleName();
//包
Package package1 = clazz3.getPackage();
//安全管理器
ProtectionDomain protectionDomain = clazz3.getProtectionDomain();
//资源
// getResource(String)
// 按指定名查找资源
URL url = clazz3.getResource("read.txt");
// getResourceAsStream(String)
// 用给定名查找资源。
InputStream inputStream = clazz3.getResourceAsStream("read.txt");
//签名
// getSigners()
// 获取类标记。
Object[] signers = clazz3.getSigners();
//当前泛型类型对象
TypeVariable<?>[] typeParameters = clazz3.getTypeParameters();
boolean instance2 = clazz3.isInstance(o);
// isInstance(Object)
// 此方法是Java语言instanceof操作的动态等价方法。
boolean instance = clazz3.isInstance(user3);
//数组
// isArray()
// 如果Class对象表示一个数组则返回true,否则返回false。
boolean array = clazz3.isArray();
//基础数据类型
// isPrimitive()
// 判定指定的Class对象是否表示一个Java的基类型。
boolean primitive = clazz3.isPrimitive();
//
//创建实例
// newInstance()
// 创建类的新实例。
User user4 = clazz3.newInstance();
//将对象转换为字符串。
// toString()
String string = clazz3.toString();
String genericString = clazz3.toGenericString();
//合成类：https://blog.csdn.net/a327369238/article/details/52608805
boolean synthetic = clazz3.isSynthetic();
}
}