java里面todo java的class是什么意思

转载

definitely 2023-06-24 20:45:57

文章标签 java里面todo java System 本地方法 文章分类 Java 后端开发

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 {
/**
 * @paramargs
 * @throwsIllegalAccessException
 * @throwsInstantiationException
 */
 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对象这个弯子，至于这么绕有什么好处，还没有深刻体会。

(持续更新中）

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。