本文原创,转载请注明原处!

红色代表的是基本组件:包(Package),修饰符(modifier),类(Class),字段(Field),构造器(Constructor)和方法(Method)。

黄色代表的是泛型组件:可定义泛型的元素(GenericDeclaration),类型(Type),泛型(TypeVariable),泛型参数类(ParameterizedType),泛型数组(GenericArrayType),通配符(WildcardType)。

蓝色代表的是注解组件:可被注解的元素(AnnotatedElement),注解后的类型(AnnotatedType),注解(Annotation),其它。

类(Class)

类不是单纯的指class定义的类,它是包括基本数据类型和数组,还包括class,interface,@interface,enum等定义出来的类型。

平常所用到的,所定义出来的类型,都可以归为现在所讲述的这个“类”,但它不包括泛型,虽然说泛型可以作为一个类型来使用。

接口:Type,GenericDeclaration,AnnotatedElement

名称

  • getName():String
  • getCanonicalName():String
  • getSimpleName():String
  • s+forName(String):Class<?>
  • s+forName(String, boolean, ClassLoader):Class<?>

示例:

public class Test {
public static void main(String[] params) throws ClassNotFoundException {
Class<?> clazz = Class.forName("test.TestClass$TestInnerClass");
System.out.println(clazz.getName());
System.out.println(clazz.getCanonicalName());
System.out.println(clazz.getSimpleName()); /*
运行结果:
test.TestClass$TestInnerClass
test.TestClass.TestInnerClass
TestInnerClass
*/
}
}

test/TestClass.java

public class TestClass {
public class TestInnerClass { }
}

类型

  • isPrimitive():boolean
    查看是否基本数据类型。
  • isArray():boolean
    查看是否数组类型。
  • isInterface():boolean
    查看是否接口类型。
  • isAnnotation():boolean
    查看是否注解类型。
  • isEnum():boolean
    查看是否枚举类型。
public class Test {
public static void main(String[] params) {
print("基本数据类型", int.class);
/*
输出结果:
基本数据类型 -> 是否基本数据类型=true
基本数据类型 -> 是否数组= false
基本数据类型 -> 是否接口= false
基本数据类型 -> 是否注解= false
基本数据类型 -> 是否枚举= false
*/ System.out.println("-------------------------");
print("数组", int[].class);
/*
输出结果:
数组 -> 是否基本数据类型=false
数组 -> 是否数组= true
数组 -> 是否接口= false
数组 -> 是否注解= false
数组 -> 是否枚举= false
*/ System.out.println("-------------------------");
print("接口", TestInterface.class);
/*
输出结果:
接口 -> 是否基本数据类型=false
接口 -> 是否数组= false
接口 -> 是否接口= true
接口 -> 是否注解= false
接口 -> 是否枚举= false
*/ System.out.println("-------------------------");
print("注解", TestAnnotation.class);
/*
输出结果:
注解 -> 是否基本数据类型=false
注解 -> 是否数组= false
注解 -> 是否接口= true
注解 -> 是否注解= true
注解 -> 是否枚举= false
*/ System.out.println("-------------------------");
print("枚举", TestEnum.class);
/*
输出结果:
枚举 -> 是否基本数据类型=false
枚举 -> 是否数组= false
枚举 -> 是否接口= false
枚举 -> 是否注解= false
枚举 -> 是否枚举= true
*/ System.out.println("-------------------------");
print("类", TestClass.class);
/*
输出结果:
类 -> 是否基本数据类型=false
类 -> 是否数组= false
类 -> 是否接口= false
类 -> 是否注解= false
类 -> 是否枚举= false
*/
} public static void print(String name, Class<?> clazz){
System.out.println(name + " -> 是否基本数据类型=" + clazz.isPrimitive());
System.out.println(name + " -> 是否数组=\t" + clazz.isArray());
System.out.println(name + " -> 是否接口=\t" + clazz.isInterface());
System.out.println(name + " -> 是否注解=\t" + clazz.isAnnotation());
System.out.println(name + " -> 是否枚举=\t" + clazz.isEnum());
} public static class TestClass { }
public static interface TestInterface { }
public static @interface TestAnnotation { }
public static enum TestEnum { }
}

注意:注解既是注解类型,又是接口类型,但它不能像接口一样,可以被实现。

  • getComponentType():Class<?>
    该类为数组类型时,可通过此方法获取其组件类型。

示例:

public class Test {
public static void main(String[] params) {
System.out.println(int[].class.getComponentType());
System.out.println(int[][].class.getComponentType()); /*
输出结果:
int
class [I
*/
}
}

  • getPackage():Package
    获取类在定义时所在的包。

修饰符

  • getModifiers():int

示例:

public class Test {
public static void main(String[] params) {
System.out.println(Modifier.toString(TestClass.class.getModifiers())); // 输出结果:
// public static final
} public static final class TestClass { }
}

内部定义

网络上查阅中,其中对内部类的划分有常规内部类,静态内部类,局部内部类,匿名内部类。下面的述语中,成员内部类是指常规内部类与静态内部类。

  • getDeclaringClass():Class<?>
    获取成员内部类在定义时所在的类。
  • getEnclosingClass():Class<?>
    获取内部类在定义时所在的类。
  • getEnclosingConstructor():Constructor
    获取局部或匿名内部类在定义时所在的构造器。
  • getEnclosingMethod():Method
    获取局部或匿名内部类在定义时所在的方法。
  • isMemberClass():boolean
    查看是否成员内部类。
  • isLocalClass():boolean
    查看是否局部内部类。
  • isAnonymousClass():boolean
    查看是否匿名内部类。

示例:

public class Test {
public static void main(String[] params) {
new Test().test();
} public void test(){
printInnerClass("常规内部类", Test.InnerClass.InnerClass2.class);
/*
输出结果:
常规内部类 -> DeclaringClass= class Test$InnerClass
常规内部类 -> EnclosingClass= class Test$InnerClass
常规内部类 -> EnclosingConstructor=null
常规内部类 -> EnclosingMethod= null
常规内部类 -> 是否成员内部类= true
常规内部类 -> 是否局部内部类= false
常规内部类 -> 是否匿名内部类= false
*/ System.out.println("---------------------------------------------------------------------------------------");
printInnerClass("静态内部类", StaticInnerClass.StaticInnerClass2.class);
/*
输出结果:
静态内部类 -> DeclaringClass= class Test$StaticInnerClass
静态内部类 -> EnclosingClass= class Test$StaticInnerClass
静态内部类 -> EnclosingConstructor=null
静态内部类 -> EnclosingMethod= null
静态内部类 -> 是否成员内部类= true
静态内部类 -> 是否局部内部类= false
静态内部类 -> 是否匿名内部类= false
*/ System.out.println("---------------------------------------------------------------------------------------");
class LocalInnerClass { }
printInnerClass("局部内部类", LocalInnerClass.class);
/*
输出结果:
局部内部类 -> DeclaringClass= null
局部内部类 -> EnclosingClass= class Test
局部内部类 -> EnclosingConstructor=null
局部内部类 -> EnclosingMethod= public void Test.test()
局部内部类 -> 是否成员内部类= false
局部内部类 -> 是否局部内部类= true
局部内部类 -> 是否匿名内部类= false
*/ System.out.println("---------------------------------------------------------------------------------------");
Object obj = new Object(){ };
printInnerClass("匿名内部类", obj.getClass());
/*
输出结果:
匿名内部类 -> DeclaringClass= null
匿名内部类 -> EnclosingClass= class Test
匿名内部类 -> EnclosingConstructor=null
匿名内部类 -> EnclosingMethod= public void Test.test()
匿名内部类 -> 是否成员内部类= false
匿名内部类 -> 是否局部内部类= false
匿名内部类 -> 是否匿名内部类= true
*/
} public static void printInnerClass(String name, Class<?> clazz){
System.out.println(name + " -> DeclaringClass=\t" + clazz.getDeclaringClass());
System.out.println(name + " -> EnclosingClass=\t" + clazz.getEnclosingClass());
System.out.println(name + " -> EnclosingConstructor=" + clazz.getEnclosingConstructor());
System.out.println(name + " -> EnclosingMethod=\t" + clazz.getEnclosingMethod());
System.out.println(name + " -> 是否成员内部类=\t" + clazz.isMemberClass());
System.out.println(name + " -> 是否局部内部类=\t" + clazz.isLocalClass());
System.out.println(name + " -> 是否匿名内部类=\t" + clazz.isAnonymousClass());
} public class InnerClass {
public class InnerClass2 { }
} public static class StaticInnerClass {
public static class StaticInnerClass2 { }
}
}

父子关系

  • getSuperclass():Class<? super T>
    获取继承的父类。
  • getGenericSuperclass():Type
  • getAnnotatedSuperclass():AnnotatedType

示例:

public class Test {
public static void main(String[] params) {
System.out.println(TestClass.class.getSuperclass());
System.out.println(TestClass.class.getGenericSuperclass());
System.out.println(TestClass.class.getAnnotatedSuperclass());
/*
运行结果:
class Test$TestSuperClass
Test.Test$TestSuperClass<java.lang.Integer>
sun.reflect.annotation.AnnotatedTypeFactory$AnnotatedParameterizedTypeImpl@a14482
*/
} public class TestSuperClass<T> { } public class TestClass extends @TestAnnotation TestSuperClass<Integer>{ } @Target(ElementType.TYPE_USE)
@Retention(RetentionPolicy.RUNTIME)
public @interface TestAnnotation { }
}
  • getInterfaces():Class<?>[]
    获取实现的接口集。
  • getGenericInterfaces():Type[]
  • getAnnotatedInterfaces():AnnotatedType[]

示例:

public class Test {
public static void main(String[] params) {
System.out.println(Arrays.toString(TestClass.class.getInterfaces()));
System.out.println(Arrays.toString(TestClass.class.getGenericInterfaces()));
System.out.println(Arrays.toString(TestClass.class.getAnnotatedInterfaces()));
/*
运行结果:
[interface Test$TestInterface]
[Test.Test$TestInterface<java.lang.Integer>]
[sun.reflect.annotation.AnnotatedTypeFactory$AnnotatedParameterizedTypeImpl@a14482]
*/
} public interface TestSuperInterface { } public interface TestInterface<T> extends TestSuperInterface { } public class TestClass implements @TestAnnotation TestInterface<Integer>{ } @Target(ElementType.TYPE_USE)
@Retention(RetentionPolicy.RUNTIME)
public @interface TestAnnotation { }
}
  • asSubclass(Class<U>):Class<? extends U>
    把该类型(子类)转换为目标类型(父类)。
  • isAssignableFrom(Class<?>):boolean
    测试该类型(父类)是否为目标类型(子类)的父类。

用例:

public class Test {
public static void main(String[] params) {
test(Object.class);
System.out.println("---------------------------------");
test(TestClass.class); /*
输出结果:
test方法 -> 获得一个clazz,但不确定它是否为TestSuperClass类型或其子类
test方法 -> 这个clazz不是TestSuperClass类型或其子类
---------------------------------
test方法 -> 获得一个clazz,但不确定它是否为TestSuperClass类型或其子类
test方法 -> 确认这个clazz是TestSuperClass类型或其子类
*/
} public static Class<? extends TestSuperClass> test(Class<?> clazz){
System.out.println("test -> 获得一个clazz,但不确定它是否为TestSuperClass类型或其子类");
if(TestSuperClass.class.isAssignableFrom(clazz)){
System.out.println("test -> 确认这个clazz是TestSuperClass类型或其子类");
return clazz.asSubclass(TestSuperClass.class);
}
System.out.println("test -> 这个clazz不是TestSuperClass类型或其子类");
return null;
} public class TestSuperClass { } public class TestClass extends TestSuperClass { }
}

成员类

  • getClasses():Class<?>[]
  • getDeclaredClasses():Class<?>[]

示例:

public class Test {
public static void main(String[] params) {
System.out.println(Arrays.toString(TestClass.class.getClasses()));
System.out.println("---------------------------------");
System.out.println(Arrays.toString(TestClass.class.getDeclaredClasses())); /*
输出结果:
[class Test$TestClass$TestMemberClass3, class Test$TestSuperClass$TestSuperMemberClass3]
---------------------------------
[class Test$TestClass$TestMemberClass1, class Test$TestClass$TestMemberClass2, class Test$TestClass$TestMemberClass3]
*/
} public class TestSuperClass { private class TestSuperMemberClass1 { } protected class TestSuperMemberClass2 { } public class TestSuperMemberClass3 { }
} public class TestClass extends TestSuperClass { private class TestMemberClass1 { } protected class TestMemberClass2 { } public class TestMemberClass3 { } }
}

构造器

  • getConstructor(Class<?>...):Constructor<T>
  • getConstructors():Constructor<?>[]
  • getDeclaredConstructor(Class<?>...):Constructor<T>
  • getDeclaredConstructors():Constructor<?>[]

示例:

public class Test {
public static void main(String[] params) {
System.out.println(Arrays.toString(TestClass.class.getConstructors()));
System.out.println(Arrays.toString(TestClass.class.getDeclaredConstructors())); /*
运行结果:
[public Test$TestClass(Test,long)]
[private Test$TestClass(Test,short), protected Test$TestClass(Test,int), public Test$TestClass(Test,long)]
*/
} public class TestClass {
private TestClass(short i){ } protected TestClass(int i){ } public TestClass(long l){ }
}
}

方法

  • getMethod(String, Class<?>...):Method
  • getMethods():Method[]
  • getDeclaredMethod(String, Class<?>...):Method
  • getDeclaredMethods():Method[]

示例:

public class Test {
public static void main(String[] params) {
System.out.println(Arrays.toString(TestClass.class.getMethods()));
System.out.println("----------------------------------");
System.out.println(Arrays.toString(TestClass.class.getDeclaredMethods())); /*
运行结果:
[public void Test$TestClass.test(long), public void Test$TestSuperClass.superTest(long), 省略Object的方法……]
----------------------------------
[public void Test$TestClass.test(long), protected void Test$TestClass.test(int), private void Test$TestClass.test(short)]
*/
} public class TestSuperClass {
private void superTest(short i){ } protected void superTest(int i){ } public void superTest(long l){ }
} public class TestClass extends TestSuperClass {
private void test(short i){ } protected void test(int i){ } public void test(long l){ }
}
}

字段

  • getField(String):Field
  • getFields():Field[]
  • getDeclaredField(String):Field
  • getDeclaredFields():Field[]

与方法同理……

实例

  • newInstance():T
    使用该类的无参构造器创建实例。
  • isInstance(Object):boolean
    测试该对象实例是否为该类的实例。
  • cast(Object):T
    把对象实例转为该类的实例。
  • getEnumConstants():T[]
    该类为枚举类型时,可通过此方法获取其所有枚举常量。

资源

  • getResource(String):URL
    获取与该类所在目录下的路径资源。
  • getResourceAsStream(String):InputStream
    和上同理……

其它

  • desiredAssertionStatus():boolean
    测试该类的断言功能是否已打开。

示例:

test/Test.java

public class Test {
public static void main(String[] params) {
Test.class.getClassLoader().setClassAssertionStatus(TestAssert.class.getName(), true);
TestAssert testAssert2 = new TestAssert();
testAssert2.test(); /*
运行结果:
TestAssert -> 断言是否已打开=true
Exception in thread "main" java.lang.AssertionError: 断言信息!
at test.TestAssert.test(TestAssert.java:6)
at test.Test.main(Test.java:10)
*/
}
}

test/TestAssert.java

public class TestAssert {
public void test(){
System.out.println("TestAssert -> 断言是否已打开=" + TestAssert.class.desiredAssertionStatus());
assert false : "断言信息!";
}
}

注:打开断言功能,还可以使用“-ea”参数打开。

  • isSynthetic():boolean
    测试该类是否由编译器编译成class文件时所增加的,否则它是由编程人员编写java源文件时所编写的。
  • getClassLoader():ClassLoader
    获取该类被加载时所用的类加载器。
  • getProtectionDomain():ProtectionDomain
    一种权限机制,制定一个代码源所拥有的权限集合,保护域就是代表一个代码源的权限集合。
  • getSigners():Object[]
    一种盖章机制,编写者编写完代码后,由签名者审核确认无误后,进行签名,同一代码可以由多个签名者审核后盖章。

反射——类(Class)的更多相关文章

  1. C# 通过反射类动态调用DLL方法

    网上看了很多关于反射的思路和方法,发现这个还算不错 //使用反射方: using System; using System.Collections.Generic; using System.Linq ...

  2. PHP的反射类ReflectionClass、ReflectionMethod使用实例

    PHP5 具有完整的反射API,添加对类.接口.函数.方法和扩展进行反向工程的能力. 反射是什么? 它是指在PHP运行状态中,扩展分析PHP程序,导出或提取出关于类.方法.属性.参数等的详细信息,包括 ...

  3. 反射类属性生成DataTable

    public class People //类名 { private static string name; //字段 private string sex;//字段 public string Se ...

  4. C#语法糖之 ReflectionSugar 通用反射类

    用法很简单: ReflectionSugar rs = new ReflectionSugar(100);//缓存100秒 ,可以不填默认不缓存 rs.有嘛点嘛   性能测试: 性能测试类源码: ht ...

  5. Java反射机制(获取Class对象的三种方式+获取Class中的构造函数进行对象的初始化+获取反射类的字段+获取反射类的一般方法)

    反射技术其实就是动态加载一个指定的类,并获取该类中的所有内容.而且将字节码文件封装成对象,并将字节码文件中的内容都封装成对象,这样便于操作这些成员,简单来说:反射技术可以对一个类进行解剖,反射大大增强 ...

  6. 01_反射_04_反射类的main方法

    [User.java] package com.Higgin.reflect; public class User { public User(){ System.out.println(" ...

  7. (转载)php反射类 ReflectionClass

    (转载)http://hi.baidu.com/daihui98/item/a67dfb8213055dd75f0ec165   php反射类 ReflectionClass 什么是php反射类,可以 ...

  8. php反射类 ReflectionClass

    什么是php反射类,顾名思义,能够理解为一个类的映射.举个样例: class fuc {        //定义一个类static function ec() {echo '我是一个类';}}$cla ...

  9. PHP 反射类学习记录

    原文:http://www.upwqy.com/details/58.html 1 开发环境 windows TP5 参考文档 http://php.net/manual/zh/class.refle ...

  10. 【译】12. Java反射——类的动态加载和重新加载

    原文地址:http://tutorials.jenkov.com/java-reflection/dynamic-class-loading-reloading.html 博主最近比较忙,争取每周翻译 ...

随机推荐

  1. jinja2 宏的简单使用总结(macro)

    Table of Contents 1. 简介 2. 用法 3. 参数和变量 4. 注意事项 4.1. macro的变量只能为如下三种: 4.2. 和block的关系: 5. 参考文档 1 简介 ji ...

  2. 【python】for循环一列

    a="哈哈哈哈,笑死我了"for i in a: print (i, end=' ') 结果 哈 哈 哈 哈 , 笑 死 我 了

  3. Nginx+uWSGI+Django+Python在Linux上的部署

    搞了一整天,终于以发现自己访问网络的端口是错误的结束了. 首先要安装Nginx,uWSGI,Django,Python,这些都可以再网上查到. 安装好后可以用 whereis 命令查看是否安装好了各种 ...

  4. 使用WMI监控进程启动与结束

    需要添加引用System.Management 代码: static void Main(string[] args) { //创建WQL事件查询,监视进程开启 var qCreate = new W ...

  5. 定位 -CLGeocoder - 编码

    #import "ViewController.h" #import <CoreLocation/CoreLocation.h> @interface ViewCont ...

  6. 【技术贴】note8 N5100刷机 双清 落雨

    双清模式:开机键 + [音量+] + HOME键 刷机模式:开机键 + [音量- ]+ HOME键 1.双清步骤: 关机时.长按音量上键+home键+开机键,直到进入recovery模式,然后选择wi ...

  7. client denied by server configuration

    http://blog.csdn.net/fdipzone/article/details/40512229

  8. Android 系统功能设置菜单 LinearLayout与relativeLayout的实现

    <?xml version="1.0" encoding="utf-8"?> <LinearLayout xmlns:android=&quo ...

  9. 单位有b\B\K\M\G的相互转换

    计算机存储计量单位 1. 计算机最小存储计量单位是:BIT(位) 2. 计算机最基本存储计量单位是:Bytes(字节) 3. Bit和Bytes的关系:8Bit=1Bytes 4. 其他常用单位:1K ...

  10. webkit中DOM 事件有多少

    webkit中DOM 事件有多少 目前客户端javascript中大量的工作就是处理浏览器,用户触发的各种事件,下面是webkit中这些事件的集合,有一些时常见的,标准规定的,而另一些则是webkit ...