newInstance
可访问性限制： newInstance()方法只能调用无参的公共构造函数。如果类没有无参公共构造函数，那么newInstance()方法将无法使用。
异常处理： newInstance()方法在创建对象时会抛出受检异常InstantiationException和IllegalAccessException，需要在使用时进行相应的异常处理。这增加了代码的复杂性。
从Java 9开始，推荐使用更安全和更灵活的方式来创建类的实例，例如：
使用带有参数的构造函数：通过获取构造函数对象并调用newInstance()方法创建对象，可以传递所需的参数。这样可以处理具有不同构造函数的情况。
使用MethodHandle：MethodHandle提供了一种更底层的方式来调用构造函数，并且没有访问权限的限制。
B.class.isAssignableFrom(A.class) 判断Class A是否等于/继承/实现ClassB
@return the {@code boolean}
value indicating whether objects of the type {@code cls} can be assigned to objects of this class
指示对象是否属于类型{@code cls}可以分配给这个类的对象
@Test
public void isAssignableFromTest() {
System.out.println(SubInterFaceA.class.isAssignableFrom(SubInterFaceA.class));//true
System.out.println(SubInterFaceA.class.isAssignableFrom(InterFaceA.class));//false
System.out.println(SubInterFaceA.class.isAssignableFrom(SuperInterFaceA.class));//false
System.out.println(InterFaceA.class.isAssignableFrom(SubInterFaceA.class));//true
System.out.println(InterFaceA.class.isAssignableFrom(InterFaceA.class));//true
System.out.println(InterFaceA.class.isAssignableFrom(SuperInterFaceA.class));//false
System.out.println(SuperInterFaceA.class.isAssignableFrom(SubInterFaceA.class));//true
System.out.println(SuperInterFaceA.class.isAssignableFrom(InterFaceA.class));//true
System.out.println(SuperInterFaceA.class.isAssignableFrom(SuperInterFaceA.class));//true
//同理
System.out.println(SubClassA.class.isAssignableFrom(SubClassA.class));
System.out.println(SubClassA.class.isAssignableFrom(ClassA.class));
System.out.println(SubClassA.class.isAssignableFrom(SuperClassA.class));
System.out.println(ClassA.class.isAssignableFrom(SubClassA.class));
System.out.println(ClassA.class.isAssignableFrom(ClassA.class));
System.out.println(ClassA.class.isAssignableFrom(SuperClassA.class));
System.out.println(SuperClassA.class.isAssignableFrom(SubClassA.class));
System.out.println(SuperClassA.class.isAssignableFrom(ClassA.class));
System.out.println(SuperClassA.class.isAssignableFrom(SuperClassA.class));
}
isInstance 判断类Class是否是参数对象本身或者父类
@return true
if {@code obj} is an instance of this class
如果{@code obj}是该类的实例，则返回true
@Test
public void isInstanceTest() {
SuperClassA subClassA = new SubClassA();
SuperClassA classA = new ClassA();
SuperClassA superClassA = new SuperClassA();
//子类是可以向上转型的
System.out.println(SubClassA.class.isInstance(subClassA));// true
System.out.println(ClassA.class.isInstance(subClassA));// true
System.out.println(SuperClassA.class.isInstance(subClassA));// true 可以是入参对象的父类
System.out.println(SubClassA.class.isInstance(classA));//false
System.out.println(ClassA.class.isInstance(classA));// true
System.out.println(SuperClassA.class.isInstance(classA));// true 可以是入参对象的父类
System.out.println(SubClassA.class.isInstance(superClassA));//false
System.out.println(ClassA.class.isInstance(superClassA));//false
System.out.println(SuperClassA.class.isInstance(superClassA));// true
System.out.println(SubClassA.class.isInstance(null));//false
System.out.println(ClassA.class.isInstance(null));//false
System.out.println(SuperClassA.class.isInstance(null));// false
/**
* instanceof ：
* java的一个二元运算符，也是一个关键字
* 判断左边对象是否是右边类本身或者子类
*
* A instanceof B：
* A为对象实例（A只能为引用数据类型），B为类名
* 注意左边只能为引用数据类型，否则会报错:
* 向上转型（多态）:
*/
//classA= (ClassA)superClassA;//直接强转会抛出异常ClassCastException
if (superClassA instanceof ClassA) {//利用instanceof关键字就可以帮助我们判断向下转型是否正确，就可以规避一些转型错误的问题！
classA = (ClassA) superClassA;
} else {
System.out.println(String.format("superClassA instanceof ClassA:{%s}", false));
}
classA = (ClassA) subClassA;
superClassA = (SuperClassA) classA;
subClassA = (SubClassA) superClassA;
if (superClassA instanceof SubClassA) {
subClassA = (SubClassA) superClassA;
System.out.println(String.format("superClassA instanceof SubClassA:{%s}", true));
} else {
System.out.println(String.format("superClassA instanceof SubClassA:{%s}", false));
}
ArrayList arrayList = Lists.newArrayList();
System.out.println(List.class.isInstance(arrayList));//true
System.out.println(List.class.isInstance(new Object()));//false
System.out.println(List.class.isInstance(new LinkedList<>()));//true
//参数可以是基本类型 自动做了装箱操做
System.out.println(Integer.class.isInstance(1));//true
System.out.println(Integer.class.isInstance(1.1));//false
System.out.println(Double.class.isInstance(1.6));//true
System.out.println(Double.class.isInstance(1));//false
}
isPrimitive 当且仅当该类表示基本类型时
@return true
if and only if this class represents a primitive type
当且仅当该类表示基本类型时
@Test
public void isPrimitiveTest() {
System.out.println(boolean.class.isPrimitive());//true
System.out.println(char.class.isPrimitive());//true
System.out.println(byte.class.isPrimitive());//true
System.out.println(short.class.isPrimitive());//true
System.out.println(long.class.isPrimitive());//true
System.out.println(float.class.isPrimitive());//true
System.out.println(double.class.isPrimitive());//true
System.out.println(void.class.isPrimitive());//true
System.out.println(SubClassA.class.isPrimitive());//false
}
isAnnotation 是否是一个注释类型
@return {@code true} if this class object represents an annotation type; {@code false} otherwise
如果这个类对象表示一个注释类型;{@code false}否则
@Test
public void isAnnotationTest() {
System.out.println(Component.class.isAnnotation());//true
System.out.println(Autowired.class.isAnnotation());//true
System.out.println(SubClassA.class.isAnnotation());//false
}
isSynthetic 是否是Java语言规范定义的合成类
@return {@code true} if and only if this class is a synthetic class as defined by the Java Language Specification.
当且仅当该类是Java语言规范定义的合成类时。
@Test
public void isSyntheticTest() {
//lambda在编译时生成匿名内部类，所以使用lambda属于我们的合成类
System.out.println(((Consumer) (c) -> System.gc()).getClass().isSynthetic());
System.out.println(((Supplier) System::nanoTime).getClass().isSynthetic());
System.out.println(((Predicate) (p) -> Boolean.FALSE).getClass().isSynthetic());
System.out.println(((Function) (f) -> "function").getClass().isSynthetic());
System.out.println(((Runnable) new Runnable() {//自己写了一个匿名内部类，编译没有生成，所以它不是合成类
@Override
public void run() {
}
}).getClass().isSynthetic());
System.out.println(((Runnable) System::nanoTime).getClass().isSynthetic());
}
字段中同理
private enum Ruben {
}
System.out.println(Ruben.class.getDeclaredField("$VALUES").isSynthetic());
//输出结果为true，我们知道枚举是在编译后会生成$VALUES字段，所以它是一个合成字段
getClassLoader 获取类加载器
类加载器参考链接: https://blog.csdn.net/weixin_56219549/article/details/121972757.
getTypeParameters
-
getTypeParameters方法返回的是TypeVariable对象的数组，Type Variable是表示类型参数的接
口，可以通过该接口获取类型参数的各种信息. -
getTypeParameters方法只能用于泛型类或泛型方法，对于非泛型类或方法,调用该方法会
返回-一个空数组. -
getTypeParameters方法返回的TypeVariable对象数组的顺序与类型参数在类或方法中的声明
顺序相同，可以通过数组的下标来获取具体的类型参数信息.
在使用getTypeParameters方法时，可以通过以下代码示例来获取泛型类或泛型方法的类型参书信息
@Test
public void getTypeParameters() {
TypeVariable<Class<TransOrderHandler>>[] typeParameters = TransOrderHandler.class.getTypeParameters();
for (TypeVariable<Class<TransOrderHandler>> typeParameter : typeParameters) {
System.out.println(typeParameter.getAnnotatedBounds());
System.out.println(typeParameter.getBounds());
System.out.println(typeParameter.getGenericDeclaration());
System.out.println(typeParameter.getName());
}
Method[] methods = TransOrderHandler.class.getMethods();
for (Method method : methods) {
Parameter[] parameters = method.getParameters();
for (Parameter parameter : parameters) {
System.out.println(parameter.getName());
System.out.println(parameter.getDeclaringExecutable());
System.out.println(parameter.getAnnotatedType());
System.out.println(parameter.getType());
System.out.println(parameter.getParameterizedType());
}
}
}
getSuperclass or getGenericSuperclass
public class ClassB extends GenericClassB<SubClassA,ClassA> implements GenericInterfaceB<SubClassA,ClassA>, InterfaceB {
@Override
public ClassA methodPublicAbstract(SubClassA subClassA) {
return null;
}
@Override
public String methodPublicAbstract() {
return null;
}
}
@return the superclass of the class represented by this object.
由该对象表示的类的超类。
getSuperclass 返回直接继承的父类（由于编译擦除，没有显示泛型参数）
getGenericSuperclass 返回直接继承的父类（包含泛型参数）
@Test
public <T extends BaseOrderVO, R> void getSuperclassTest() {
Class<? super ClassB> superclass = ClassB.class.getSuperclass();
System.out.println(superclass.getName());
Type genericSuperclass = ClassB.class.getGenericSuperclass();
System.out.println(genericSuperclass.getTypeName());
if (genericSuperclass instanceof ParameterizedType) {
Type[] types = ((ParameterizedType) genericSuperclass).getActualTypeArguments();
for (Type type : types) {
System.out.println(type.getTypeName());
}
}
}
输出
getInterfaces or getGenericInterfaces
@return an array of interfaces implemented by this class
由这个类实现的接口数组
getInterfaces 返回由此对象表示的类或接口实现的接口。
Returns the {@code Type}s representing the interfaces directly implemented by the class or interface represented by this object.释意：返回表示由此对象表示的类或接口直接实现的接口的{@code Type}。
getGenericInterfaces 返回直接继承的接口（包含泛型参数）
@Test
public void getInterfacesTest() {
Class<?>[] Interfaces = ClassB.class.getInterfaces();
Type[] genericInterfaces = ClassB.class.getGenericInterfaces();
}
getPackage 包信息
@return the package of the class, or null if no package information is available from the archive or codebase.
类的包，如果存档或代码库中没有可用的包信息，则为空。
@Test
public <T extends BaseOrderVO, R> void getPackageTest() {
System.out.println(GenericClassB.class.getPackage());
System.out.println(GenericInterfaceB.class.getPackage());
}
输出
package com.buyan.entity.reflect
package com.buyan.entity.reflect.i
getComponentType 得到数组里的类型。
@return the {@code Class} representing the component type of this class if this class is an array
{@code Class}表示这个类的组件类型，如果这个类是一个数组
如果此类不表示数组类，则此方法返回null
@Test
public void getComponentTypeTest() {
List<Object> arrays = new ArrayList<>();
arrays.add(new ClassA());
arrays.add(new float[]{2l});
arrays.add(new double[]{2.2});
arrays.add(new int[]{1});
arrays.forEach(v->
System.out.println(v.getClass().getComponentType()));
Object stringArray = Array.newInstance(String.class, 3);
Array.set(stringArray, 0, "Mahesh");
Array.set(stringArray, 1, "Ramesh");
Array.set(stringArray, 2, "Suresh");
System.out.println(stringArray.getClass().getComponentType());
int[] dim = new int[] { 5, 10, 15 };
Object array = Array.newInstance(Integer.TYPE, dim);
Object arrayObj = Array.get(array, 3);
Class<?> cls = arrayObj.getClass().getComponentType();
System.out.println(cls);
}
getModifiers 标识该类的修饰符
返回值说明
getModifiers()方法的返回值是一个整数，这个整数实际上是修饰符的位标志组合。Java使用位运算来高效地表示多个布尔属性，每个修饰符对应一个二进制位。这种方式允许通过一个整数同时表示多个修饰符状态。下面是常见的修饰符及其对应的位值：
@Test
public void getModifiersTest() {
/**
* public: 0x0001（1）
* private: 0x0002（2）
* protected: 0x0004（4）
* static: 0x0008（8）
* final: 0x0010（16）
* synchronized: 0x0020（32）
* volatile: 0x0040（64） - 对于字段有效
* transient: 0x0080（128） - 对于字段有效
* native: 0x0100（256） - 对于方法有效
* interface: 0x0200（512） - 对于类或接口有效
* abstract: 0x0400（1024） - 对于类或方法有效
* strictfp: 0x0800（2048） - 对于类或方法有效
*/
int modifiers = ReflectTest.class.getModifiers();
System.out.println(Modifier.toString(modifiers) + " getModifiers: " + modifiers);
modifiers = ProtectedClass.class.getModifiers();
System.out.println(Modifier.toString(modifiers) + " getModifiers: " + modifiers);
modifiers = DefaultClass.class.getModifiers();
System.out.println(Modifier.toString(modifiers) + " getModifiers: " + modifiers);
modifiers = PrivateClass.class.getModifiers();
System.out.println(Modifier.toString(modifiers) + " getModifiers: " + modifiers);
//例如，如果一个方法是private和static的，那么它的修饰符位标志将是0x0002（public）加上0x0008（static）。
modifiers = PrivateStaticClass.class.getModifiers();
System.out.println(Modifier.toString(modifiers) + " getModifiers: " + modifiers);
}
protected class ProtectedClass{}
class DefaultClass{}
private class PrivateClass{}
private static class PrivateStaticClass{}
输出
getSigners 获取该类的签名者
@return the signers of this class, or null if there are no signers. In particular, this method returns null if this object represents a primitive type or void.
该类的签名者，如果没有签名者，则为空。特别是，如果此对象表示基本类型或void，则此方法返回null。
public native Object[] getSigners();
getEnclosingMethod、getEnclosingConstructor、getEnclosingClass
Enclosing ： 封闭；围合（可以理解为直接外部类或最近的）
getEnclosingMethod
当此Class对象在方法内部表示本地或匿名类时，使用getEnclosingMethod()方法返回基础类的最新封闭方法
getEnclosingConstructor
表示底层类的直接封闭构造函数,如果此Class对象表示构造函数中的本地或匿名类,则返回null。
getEnclosingClass
方法返回底层类的直接封闭类。 如果该类是顶级类，则此方法返回 null。
public Object o;
class InnerClass{class InnerInnerClass{}}
public ReflectTest(){class InnerClass{} o = new InnerClass();}
public Object method(){class InnerClass{} return new InnerClass();}
private Object methodCopy(String str){class InnerClass{String fileStr; InnerClass(String str){this.fileStr=str;}} return new InnerClass(str);}
@Test
public void getEnclosingTest() {
ReflectTest reflectTest = new ReflectTest();
Class<?> clazz = reflectTest.o.getClass();
Constructor<?> enclosingConstructor = reflectTest.o.getClass().getEnclosingConstructor();
System.out.println(enclosingConstructor);
System.out.println(reflectTest.method().getClass().getEnclosingMethod());
System.out.println(reflectTest.methodCopy("").getClass().getEnclosingMethod());
System.out.println(ReflectTest.InnerClass.InnerInnerClass.class.getEnclosingClass());
}
输出
getDeclaringClass 获取对应类的声明类Class对象
public interface IService {
void method();
}
public static class ServiceClassA {
IService getIService() {
//匿名内部类
return new IService() {
@Override
public void method() {
System.out.println(this.getClass().getEnclosingClass());
System.out.println(this.getClass().getDeclaringClass());
}
};
}
}
public static class ServiceClassB {
IService getIService() {
//匿名内部类lambda写法
return () -> {
System.out.println(this.getClass().getEnclosingClass());
System.out.println(this.getClass().getDeclaringClass());
};
}
}
@Test
public void getDeclaringClassTest() {
/**
* 1、Class.GetEnclosingClass
* <doc>获取对应类的直接外部类Class对象</doc>
* 2、Class.GetDeclaringClass
* <doc>获取对应类的声明类Class对象</doc>
* 3、两者的区别
* <p>
* GetEnclosingClass与GetDeclaringClass很相近
* 两者的区别在于匿名内部类、getEnclosingClass对匿名内部类也有效
*/
Class<InnerClass> innerClass = InnerClass.class;
System.out.println(innerClass.getEnclosingClass().getName());
System.out.println(innerClass.getDeclaringClass().getName());
//注意：GetEnclosingClass获取的是直接定义该类的外部类Class实例、这点和getDeclaringClass一致
Class<InnerClass.InnerInnerClass> innerInnerClassClass = InnerClass.InnerInnerClass.class;
System.out.println(innerInnerClassClass.getEnclosingClass().getName());
System.out.println(innerInnerClassClass.getDeclaringClass().getName());
//针对匿名内部类的测试
ServiceClassA serviceClassA = new ServiceClassA();
IService iService = serviceClassA.getIService();
iService.method();
System.out.println(iService.getClass().getEnclosingClass());
System.out.println(iService.getClass().getDeclaringClass());
//针对匿名内部类lambda写法的测试
ServiceClassB serviceClassB = new ServiceClassB();
iService = serviceClassB.getIService();
iService.method();
System.out.println(iService.getClass().getEnclosingClass());
System.out.println(iService.getClass().getDeclaringClass());
}
输出
getDeclaringClasss 获取对应类的声明类Class类中的class
@Test
public void getDeclaringClassTest() {
Class<?>[] declaredClasses = ReflectTest.class.getDeclaredClasses();
for (Class<?> declaredClass : declaredClasses) {
System.out.println(declaredClass.getName());
}
}
输出
getName()，getSimpleName，getTypeName，getCanonicalName
参考连接https://blog.csdn.net/Goodbye_Youth/article/details/83536840.
@return the name of the class or interfacerepre sented by this object.
由该对象表示的类或接口的名称。
getName 如 [Ljava.lang.String;
@return the simple name of the underlying class
底层类的简单名称
getSimpleName String[]
@return an informative string for the name of this type
此类型名称的信息字符串
getTypeName 如 java.lang.String[]
@return the canonical name of the underlying class if it exists, and {@code null} otherwise.
如果存在，则为基础类的规范名称，否则为{@code null}。
getCanonicalName
@Test
public void getNameTest() {
// 普通类
Class<?> clazz = ReflectTest.class;
System.out.println(clazz.getName());
System.out.println(clazz.getSimpleName());
System.out.println(clazz.getCanonicalName());
System.out.println(clazz.getTypeName());
// 基本数据类型
System.out.println(void.class.getName()); // int
System.out.println(void.class.getCanonicalName()); // int
System.out.println(void.class.getSimpleName()); // int
System.out.println(void.class.getTypeName()); // int
// 数组
System.out.println(String[].class.getName()); // [Ljava.lang.String;
System.out.println(String[].class.getCanonicalName()); // java.lang.String[]
System.out.println(String[].class.getSimpleName()); // String[]
System.out.println(String[].class.getTypeName()); // java.lang.String[]
// 成员内部类
System.out.println(InnerClass.class.getName());
System.out.println(InnerClass.class.getCanonicalName());
System.out.println(InnerClass.class.getSimpleName());
System.out.println(InnerClass.class.getTypeName());
//匿名内部类
ServiceClassA serviceClassA = new ServiceClassA();
clazz = serviceClassA.getIService().getClass();
System.out.println(clazz.getName());
System.out.println(clazz.getSimpleName());
System.out.println(clazz.getCanonicalName());
System.out.println(clazz.getTypeName());
//匿名内部类lambda
ServiceClassB serviceClassB = new ServiceClassB();
clazz = serviceClassB.getIService().getClass();
System.out.println(clazz.getName());
System.out.println(clazz.getSimpleName());
System.out.println(clazz.getCanonicalName());
System.out.println(clazz.getTypeName());
}
isAnonymousClass,isLocalClass,isMemberClass
@return {@code true} if and only if this class is an anonymous class.
当且仅当这个类是一个匿名类。
isAnonymousClass
@return {@code true} if and only if this class is a local class.
当且仅当这个类是一个局部类。
isLocalClass
@return {@code true} if and only if this class is a member class.
当且仅当这个类是一个成员类。
isMemberClass()
@Test
public void isClassTest() {
//匿名内部类
ServiceClassA serviceClassA = new ServiceClassA();
Class<?> clazz = serviceClassA.getIService().getClass();
System.out.println(clazz.isAnonymousClass());//true
System.out.println(clazz.isLocalClass());//false
System.out.println(clazz.isMemberClass());//false
//匿名内部类lambda
ServiceClassB serviceClassB = new ServiceClassB();
clazz = serviceClassB.getIService().getClass();
System.out.println(clazz.isAnonymousClass());//false
System.out.println(clazz.isLocalClass());//false
System.out.println(clazz.isMemberClass());//false
//成员类
clazz = InnerClass.InnerInnerClass.class;
System.out.println(clazz.isAnonymousClass());//false
System.out.println(clazz.isLocalClass());//false
System.out.println(clazz.isMemberClass());//true
class AA {
}//方法内局部类
clazz = AA.class;
System.out.println(clazz.isAnonymousClass());//false
System.out.println(clazz.isLocalClass());//true
System.out.println(clazz.isMemberClass());//false
{class BB {}//块内局部类
clazz = BB.class;
System.out.println(clazz.isAnonymousClass());//false
System.out.println(clazz.isLocalClass());//true
System.out.println(clazz.isMemberClass());//false
}
}
getClasses(包括嵌套类、嵌套接口和枚举类型)
getClasses
获取某个类中所有公共类和接口的 Class 对象，这包括嵌套类、嵌套接口和枚举类型
getDeclaredClasses
获取某个类中声明的所有字段，包括公有、私有、受保护的类和接口的 Class 对象，这包括嵌套类、嵌套接口和枚举类型
@Test
public void getClassesTest() {
for (Class<?> aClass : ReflectTest.class.getClasses()) {
System.out.println(aClass.getName());
}
System.out.println("------------------------");
for (Class<?> aClass : ReflectTest.class.getDeclaredClasses()) {
System.out.println(aClass.getName());
}
}
输出
同理
getFields
getMethods
getConstructors
getField
getMethod
getConstructor
不包括继承的字段和方法等，简单理解就是当前类的。
包括4重访问权限
getDeclaredFields
getDeclaredMethods
getDeclaredConstructors
getDeclaredField
getDeclaredMethod
getDeclaredConstructor
getResourceAsStream getResource
Class.getResourceAsStream(String path) ：
path 不以’/'开头时默认是从此类所在的包下取资源，以’/'开头则是从 ClassPath根下获取。其只是通过path构造一个绝对路径，最终还是由ClassLoader获取资源。
Class.getClassLoader.getResourceAsStream(String path) ：
默认则是从ClassPath根下获取，path不能以’/'开头，最终是由 ClassLoader获取资源。
@Test
public void getResourceTest() {
URL resource = ReflectTest.class.getClassLoader().getResource("");
System.out.println("根路径" + resource.getPath());
resource = ReflectTest.class.getResource("");
System.out.println("包路径" + resource.getPath());
resource = ReflectTest.class.getResource("/");
System.out.println("包路径" + resource.getPath());
// 获取不到, 因为是相对于包路径
URL resource1 = ReflectTest.class.getResource("application.yaml");// null
// 下面3个能获取到, 因为是相对于classpath的路径
URL resource2 = ReflectTest.class.getResource("/application.yaml");
URL resource3 = ReflectTest.class.getClassLoader().getResource("application.yaml");
URL resource4 = ReflectTest.class.getClassLoader().getResource("./application.yaml");
// 获取不到，无法被解析为相对于classpath的路径
URL resource5 = ReflectTest.class.getClassLoader().getResource("/application.yaml");//null
System.out.println(resource1); // null
System.out.println(resource2); // 非null
System.out.println(resource3); // 非null
System.out.println(resource4); // 非null
System.out.println(resource5); // null
}
getProtectionDomain
@Test
public void getProtectionDomainTest() {
ProtectionDomain protectionDomain = ReflectTest.class.getProtectionDomain();
System.out.println(protectionDomain);
}
输出
desiredAssertionStatus 返回将分配给此类的断言状态。
@Test
public void desiredAssertionStatusTest() {
boolean b = ReflectTest.class.desiredAssertionStatus();
System.out.println(b);
}
输出
isEnum getEnumConstants
@return true if and only if this class was declared as an enum in the source code
当且仅当在源代码中将该类声明为enum时为True
isEnum
@return an array containing the values comprising the enum class represented by this Class object in the order they’re declared, or null if this Class object does not represent an enum type
一个数组，其中包含由这个class对象表示的枚举类的值，按照它们的声明顺序，如果这个class对象不表示枚举类型，则为空
getEnumConstants
@Test
public void enumTest(){
Class clazz = EnumValue.class;
System.out.println(clazz.isEnum());
for (Object enumConstant : clazz.getEnumConstants()) {
System.out.println(enumConstant);
}
}
输出
cast 将对象强制转换为所表示的类或接口
Class.cast 主要用于以下情景：
在反射中，当需要通过反射获取对象实例并将其转换为特定类型时，Class.cast 可以用于安全地进行类型检查和转换。
在动态编程场景下，当无法在编译时确定类型，但又需要进行类型转换时，Class.cast 提供了一种可靠的转换方式。
@Test
public void castTest(){
ClassA classA = new ClassA();
System.out.println(classA);
SuperClassA superClassA = SuperClassA.class.cast(classA);
System.out.println(superClassA);
try {
SubClassA subClassA = SubClassA.class.cast(classA);
}catch (ClassCastException e){
System.out.println("ClassCastException");
}
}
}
asSubclass
Casts this {@code Class} object to represent a subclass of the class represented by the specified class object. Checks that the cast is valid, and throws a {@code ClassCastException} if it is not. If this method succeeds, it always returns a reference to this class object.
强制转换这个{@code Class}对象来表示由指定的类对象表示的类的子类。检查强制转换是否有效，如果无效则抛出{@code ClassCastException}。如果这个方法成功，它总是返回对这个类对象的引用。
@Test
public void asSubclassTest(){
ClassA classA = new ClassA();
System.out.println(classA);
Class<? extends ClassA> aClass = SubClassA.class.asSubclass(classA.getClass());
System.out.println(aClass);
try {
aClass = SuperClassA.class.asSubclass(classA.getClass());
}catch (ClassCastException e){
System.out.println("ClassCastException");
}
getAnnotation
getAnnotation
isAnnotationPresent
1.getAnnotationsByType方法只能获取直接应用在元素上的注解，无法获取间接应用的注解。例如，如果类A应用了注解B，类B应用了注解C，那么通过
2.getAnnotationsByType方法只能获取由源代码中的注解声明而来的注解，无法获取由框架或工具生成的注解。这意味着，如果某个注解是在运行时由框架或工具生成的，那么getAnnotationsByType方法无法获取到该注解。
getAnnotationsByType
getAnnotations
getDeclaredAnnotation
getDeclaredAnnotationsByType
getDeclaredAnnotations
getAnnotatedSuperclass
getAnnotatedInteces
@Test
public void annotationTest () {
Class<?> clazz = Configuration.class;
System.out.println(clazz.isAnnotation());
System.out.println(clazz.isAnnotationPresent(Component.class));
System.out.println(clazz.isAnnotationPresent(Ann.class));
System.out.println(clazz.getAnnotationsByType(Component.class));
System.out.println(Ann.class.getAnnotationsByType(ComponentScan.Filter.class));
for (Annotation annotation : clazz.getAnnotations()) {
System.out.println(annotation);
}
System.out.println("------"+"getDeclaredAnnotations"+"------");
for (Annotation annotation : clazz.getDeclaredAnnotations()) {
System.out.println(annotation);
}
System.out.println("------"+"getDeclaredAnnotation"+"------");
Component declaredAnnotation = clazz.getDeclaredAnnotation(Component.class);
System.out.println(declaredAnnotation);
System.out.println("------"+"getAnnotatedSuperclass"+"------");
AnnotatedType annotatedSuperclass = clazz.getAnnotatedSuperclass();
System.out.println(annotatedSuperclass);
annotatedSuperclass = ClassB.class.getAnnotatedSuperclass();
System.out.println(annotatedSuperclass);
System.out.println("------"+"getAnnotatedInterfaces"+"------");
AnnotatedType[] annotatedInterfaces = ClassB.class.getAnnotatedInterfaces();
for (AnnotatedType annotatedInterface : annotatedInterfaces) {
System.out.println(annotatedInterface);
}
}
