Java Class类理解

Java Class类理解:

首先,Class是一个java类,跟Java API中定义的诸如Thread、Integer类、我们自己定义的类是一样,也继承了Object(Class是Object的直接子类)。总之,必须明确一点,它其实只是个类,只不过名字比较特殊。更进一步说,Class是一个java中的泛型类型。

对于我们自己定义的类,我们用类来抽象现实中的某些事物,比如我们定义一个名称为Car的类来抽象现实生活中的车,然后可以实例化这个类,用这些实例来表示我的车、你的车、黄的车、红的车等等。

好了,现在回到Class 类上来,这个类它抽象什么了?它的实例又表示什么呢?

在一个运行的程序中,会有许多类和接口存在。我们就用Class这个来来表示对这些类和接口的抽象,而Class类的每个实例则代表运行中的一个类。例如,运行的程序有A、B、C三个类,那么Class类就是对A、B、C三个类的抽象。所谓抽象,就是提取这些类的一些共同特征,比如说这些类都有类名,都有对应的hashcode,可以判断类型属于class、interface、enum还是annotation。这些可以封装成Class类的域,另外可以定义一些方法,比如获取某个方法、获取类型名等等。这样就封装了一个表示类型(type)的类。

需要注意的是,这个特殊的Class类没有公开的构造函数,那怎么获取Class类的实例呢?有几个途径。

1.      当Java虚拟机载入一个类的时候,它就会自动创建一个Class类的实例来表示这个类。例如,虚拟机载入Car这个来的时候,它就会创建一个Class类的实例。然后可以通过以下方法获得这个Class对象:

java.lang.Class classObj = ClassName.class;

2. 可以通过调用类加载器(ClassLoader)的defineClass()方法来得到一个实例。这个方法接受一个byte数组,载入这个byte数组否成的class类,同时实例化一个Class对象。

3. ClassName.class( )   ClassName.getClass( )

现在来分析一下Class类的源码(java.lang.Class):

public final

class Class<T>implementsjava.io.Serializable,

java.lang.reflect.GenericDeclaration,

java.lang.reflect.Type,

java.lang.reflect.AnnotatedElement {…

ClassClass<T>,前一个Class表示这是一个类的声明,第二个Class是类的名称,<T>表示这是一个泛型类,带有参数T.同时,Class类实现了许多接口。

紧接着定义了几个静态变量:

private static final int ANNOTATION= 0x00002000;

private static final int ENUM      = 0x00004000;

private static final int SYNTHETIC = 0x00001000;

接着定义一个本地方法registerNatives(),并在静态块中调用:

private static native void registerNatives();

static {

registerNatives();

}

私有的构造函数:

private Class() {}

访问修饰符是private,程序员是无法直接调用这个构造函数,只能通过JVM来调用它,构造一个Class实例。

public String toString() {

return (isInterface() ?"interface " : (isPrimitive() ? "" : "class"))

+ getName();

}

这是Class对象实例的字符串表示方法,应该不陌生。那么,它返回什么东西呢?

>如果这个Class对象实例所表示的是一个Java类,则返回class full_classname.

例如java.lang.Math.java这个类,它所对应的Class实例的toString方法返回的就是class java.lang.Math

>如果是接口,将class改成interface。还有一种特殊情况,如果Class实例表示的是void类型,则发挥void。如果是基本类型,一样的返回基本类型的名称。

静态方法forName:

public static Class<?> forName(String className)

throws ClassNotFoundException{

returnforName0(className,true, ClassLoader.getCallerClassLoader());

}

根据给定的类名参数className,查找与className相对应的Class实例,然后加载、连接该实例对象,之后返回这个Class实例。其中例如以下代码段将输出:

class java.lang.Thread

public class ClassTest {

/**

@param  args

*/

public static void main(String[] args) {

try {

System.out.println( Class.forName("java.lang.Thread") );

catch (ClassNotFoundException e) {

e.printStackTrace();

System.out.println("No ClassNamed java.lang.Thread");

}

}

}

forName方法重载:

public static Class<?> forName(String name, boolean initialize,

ClassLoaderloader)

throws ClassNotFoundException

{

if (loader ==null) {

SecurityManager sm = System.getSecurityManager();

if (sm !=null) {

ClassLoader ccl = ClassLoader.getCallerClassLoader();

if (ccl !=null) {

sm.checkPermission(

SecurityConstants.GET_CLASSLOADER_PERMISSION);

}

}

}

returnforName0(name, initialize,loader);

}

注意到这个forName重载方法中多了两个方法参数,其中initialize这个boolean类型指定是否要初始化对应的Class实例,loader指定加载Class实例的加载器。留意这个方法可能抛出的异常还是比较多的,比如连接失败、找不到对应的类等等。

forName0本地方法:

private static native Class<?> forName0(String name,boolean initialize,

ClassLoaderloader)

throws ClassNotFoundException;

这是一个本地方法,在前面的静态方法forName的两个版本中都调用了这个本地方法。

newInstance()方法:

public T newInstance()          // T是个泛型参数,是Class实例所表示的Java类

throws InstantiationException,IllegalAccessException

{

if (System.getSecurityManager()!=null) {

checkMemberAccess(Member.PUBLIC, ClassLoader.getCallerClassLoader());

}

return newInstance0();     //这是一个本地方法,也在Class类中定义

}

注意这是一个实例方法,必须由Class类的实例对象调用。例如,有一个代表java.lang.Thread类的Class实例对象objec1,也就是说,泛型参数T此时就是Thread,object1这个实例代表Thread这个类。好了,现在调用object1的newInstance方法,即object1.newInstance(),此时这个调用将返回一个Thread类的对象。简单验证:

public class ForName {

/**

@param args

@throws IllegalAccessException

@throws InstantiationException

*/

public static void main(String[] args) throws InstantiationException, IllegalAccessException {

Class<?> c = null ;

try {

c = Class.forName("java.lang.Thread");

catch (ClassNotFoundException e) {

e.printStackTrace();

}

Thread thread = (Thread) c.newInstance(); //类型转化一下

System.out.println(thread.getId());

}

}

在我机子中,上述代码输出 8 。即c.newInstance产生一个ID为8的新线程。

getClassLoader:

public ClassLoader getClassLoader() {

ClassLoader cl = getClassLoader0();

if (cl ==null)

return null;   // Bootstrap

SecurityManager sm = System.getSecurityManager();

if (sm !=null) {

ClassLoader ccl = ClassLoader.getCallerClassLoader();

if (ccl !=null && ccl != cl&& !cl.isAncestor(ccl)) {

sm.checkPermission(SecurityConstants.GET_CLASSLOADER_PERMISSION);

}

}

return cl;

}

//Package-private to allow ClassLoader access

native ClassLoadergetClassLoader0();   // 本地方法

这个方法返回该Class对象代表的类的类加载器。如果类的加载器是Bootstrap,则返回null。下面的代码输出:The ClassLoader of Thread Class is Bootstrap

Class<?> classObj= Thread.class;

ClassLoader loader = classObj.getClassLoader();

if (loader ==null) {

System.out.println("TheClassLoader of Thread Class is Bootstrap");

else {

System.out.println(loader);

}

获取父类方法:getSuperclass()

public native Class<? super T> getSuperclass();

这是一个本地方法,这里的逻辑有点饶,方法返回的是这个Class对象所代表的Java类的父类对应的的Class 对象。

例如: Thread.class.getSuperclass()将返回一个代表Thread类的Class对象,Thread.class.getSuperclass().toString()则输出这个Class对象的字符串表示:classjava.lang.Object。其实这里的关系无非就是说Thread的超类是Object。只是饶了Class对象这个弯子,至于这么绕有什么好处,还没有深刻体会。

时间: 2024-11-08 19:19:47

Java Class类理解的相关文章

深入理解java嵌套类和内部类

一.什么是嵌套类及内部类 可以在一个类的内部定义另一个类,这种类称为嵌套类(nested classes),它有两种类型:静态嵌套类和非静态嵌套类.静态嵌套类使用很少,最重要的是非静态嵌套类,也即是被称作为内部类(inner).嵌套类从JDK1.1开始引入.其中inner类又可分为三种: 其一.在一个类(外部类)中直接定义的内部类: 其二.在一个方法(外部类的方法)中定义的内部类: 其三.匿名内部类. 下面,我将说明这几种嵌套类的使用及注意事项. 二.静态嵌套类 如下所示代码为定义一个静态嵌套类

(转)《深入理解java虚拟机》学习笔记5——Java Class类文件结构

Java语言从诞生之时就宣称一次编写,到处运行的跨平台特性,其实现原理是源码文件并没有直接编译成机器指令,而是编译成Java虚拟机可以识别和运行的字节码文件(Class类文件,*.class),字节码文件是一种平台无关的中间编译结果,字节码文件由java虚拟机读取,解析和执行,java虚拟机屏蔽了不同操作系统和硬件平台的差异性. 如今的java虚拟机已经称为一种通用平台,不但能够运行java语言,Groovy,JRuby,Jython等一大批动态语言也可以直接在Java虚拟机上运行,其原理也是这

java常量池理解

String类两种不同的创建方式 String s1 = "zheng"; //第一种创建方式 String s2 = new String("junxiang"); //第二种创建方式 第一种创建方式是编译期在常量池中创建对象,如果常量池中已经存在"zheng"这个String对象,就将地址赋给s1.第二种创建方式是运行期在堆中创建对象,无论堆中是否已有都会重新创建一个对象. String s1 = new String("xyz&q

java基础知识回顾之java Thread类学习(八)--java多线程通信等待唤醒机制经典应用(生产者消费者)

 *java多线程--等待唤醒机制:经典的体现"生产者和消费者模型 *对于此模型,应该明确以下几点: *1.生产者仅仅在仓库未满的时候生产,仓库满了则停止生产. *2.消费者仅仅在有产品的时候才能消费,仓空则等待. *3.当消费者发现仓储没有产品可消费的时候,会唤醒等待生产者生产. *4.生产者在生产出可以消费的产品的时候,应该通知等待的消费者去消费. 下面先介绍个简单的生产者消费者例子:本例只适用于两个线程,一个线程生产,一个线程负责消费. 生产一个资源,就得消费一个资源. 代码如下: pub

Java虚拟机类装载的原理及实现(转)

Java虚拟机类装载的原理及实现(转) 一.引言 Java虚拟机(JVM)的类装载就是指将包含在类文件中的字节码装载到JVM中, 并使其成为JVM一部分的过程.JVM的类动态装载技术能够在运行时刻动态地加载或者替换系统的某些功能模块, 而不影响系统其他功能模块的正常运行.本文将分析JVM中的类装载系统,探讨JVM中类装载的原理.实现以及应用. 二.Java虚拟机的类装载实现与应用 2.1 装载过程简介 所谓装载就是寻找一个类或是一个接口的二进制形式并用该二进制形式来构造代表这个类或是这个接口的c

一大波Java来袭(三)Java常用类

本文简单介绍集中Java常用类 不同种类的工具用于处理不同的工作.比如:厨房中的工具用于烹饪:农场中的工具用于养殖--对于Java的学习中处理不同的工作也要采用不同的工具.如:处理数学函数问题用Math类.针对文件的操作采用File类--这也充分体现了Java面向对象的特点 一.字符串类(重点理解内存模型) (一)String Java.lang.String字符串常量,具有不可变性. (二)StringBuffer Java.lang.StringBuffer字符串可变量,是线程安全的. (三

有关JAVA多线程的理解

不同于c++等语言的调用操作系统的线程调控机制来实现多线程,java语言内置了多线程的api包,因此可以更加方便的使用多线程技术.(1)线程的问题.进程是程序的一次动态执行过程,它对应了从代码加载.执行至执行完毕的一个完整过程,这个过程也是进程本身从产生.发展至消亡的过程.线程是比进程更小的单位,一个进程执行过程中可以产生多个线程,每个线程有自身的产生.存在和消亡的过程,也是一个动态的概念.每个进程都有一段专用的内存区域,而线程间可以共享相同的内存区域(包括代码和数据),并利用这些共享单元来实现

从字节码和JVM的角度解析Java核心类String的不可变特性

1. 前言 最近看到几个有趣的关于Java核心类String的问题. String类是如何实现其不可变的特性的,设计成不可变的好处在哪里. 为什么不推荐使用+号的方式去形成新的字符串,推荐使用StringBuilder或者StringBuffer呢. 翻阅了网上的一些博客和stackoverflow,结合自己的理解做一个汇总. 2. String类是如何实现不可变的 String类的一大特点,就是使用Final类修饰符. A class can be declared final if its

Java入门——深入理解Java三大特性

Java入门——深入理解Java三大特性 本Blog内容: 封装 继承 多态 封装 封装把一个对象的属性私有化,同时提供一些可以被外界访问的属性的方法(getter,setter),如果不想被外界方法,我们大可不必提供方法给外界访问. 封装确实可以使我们容易地修改类的内部实现,而无需修改使用了该类的客户代码. 可以对成员变量进行更精确的控制.(在setter方法中进行实际意义的校验) 总结:控制属性访问权限,不是你想改就能改.容易修改属性类型.精确控制属性的取值范围. 继承 继承是使用已存在的类