Java 中的 java.lang.Class 类

2024年9月10日 | 阅读 25 分钟

Java 的 **java.lang.Class** 类是 Java 反射 API 的一个基本组成部分，它允许软件工程师在编码过程中检查和修改类。作为 java.lang 包的一部分，它特指 Java 应用程序中的一个特定类。从 Class 类实例化的对象代表了当前正在运行的 Java 程序中的类和接口。Java 的 "Class" 类提供了诸如 Boolean、Byte、Char、Short、Int、Long 和 FloatingPoint 值等基本数据类型。与其他大多数类不同，"Class" 没有公共构造函数，而是在运行时由 Java 虚拟机 (JVM) 在执行过程中创建。

Java 中的 Class 类充当了当前运行的 Java 程序中类和接口的表示。它提供了各种方法来检索有关类的信息，包括其名称、超类、实现的接口和方法。

Class 类的方法

方法	描述
getName()	`java.lang.Class` 类中的 `getName()` 方法返回 Class 对象所代表的类或接口的完全限定名。它经常在反射中使用，用于获取完整的类名，当适用时，包括包名。
getSimpleName()	getSimpleName() 方法是 java.lang.Class 类的一部分，用于在反射 API 中检索 Class 对象所代表的类或接口的简单名称。
getSuperclass()	它返回一个 Class 对象，该对象代表此 Class 对象所代表的类或接口的超类。
getInterfaces()	它返回一个 Class 对象数组，该数组代表当前 Class 对象所代表的类或接口所实现的接口。
getField(String name)	它用于获取一个 Field 对象，该对象代表当前 Class 对象所代表的类或接口中指定名称的公共字段。
getMethod(String name, Class<?>… parameterTypes)	它用于获取一个 Method 对象，该对象代表当前 Class 对象所代表的类或接口中指定名称和参数类型的公共方法。
newInstance()	它会创建一个代表该类的新实例，前提是该类有一个公共的、无参数的构造函数。
isInstance(Object obj)	isInstance(Object obj) 方法是反射 API 中 java.lang.Class 类的一部分，用于检查提供的对象是否是当前 Class 对象所代表的类或接口的实例，并返回 true 或 false。
isAssignableFrom(Class<?> cls)	它检查当前 Class 对象所代表的类或接口是否可以从指定的类或接口 (cls) 赋值，并返回 true 或 false。

示例

文件名: ClassInfoExample.java

import java.util.Arrays;

public class ClassInfoExample {
    public static void main(String[] args) throws Exception {
        // Obtain the Class object for the String class
        Class<?> stringClass = String.class;

        // Display information about the String class
        System.out.println("The class name is: " + stringClass.getName());
        System.out.println("The simple class name is: " + stringClass.getSimpleName());

        // Display the superclass of the String class
        System.out.println("The superclass is: " + stringClass.getSuperclass().getName());

        // Display the interfaces implemented by the String class
        System.out.println("The interfaces implemented are: " + Arrays.toString(stringClass.getInterfaces()));

        // Check if String is assignable from Object
        System.out.println("Is it possible to assign String to Object? " + String.class.isAssignableFrom(Object.class));
    }
}

输出

The class name is: java.lang.String
The simple class name is: String
The superclass is: java.lang.Object
The interfaces implemented are: [interface java.io.Serializable, interface java.lang.Comparable, interface java.lang.CharSequence]
Is it possible to assign String to Object? false

创建 Class 对象

在 Java 中创建 Class 对象可以通过多种方法实现。以下是三种常用的方法：

1. Class.forName("className")

Class.forName(String className) 方法是 Class 类的一个静态工厂方法。它为提供的类名（字符串形式）创建一个 Class 对象。类名必须包含完整的路径，即我们要查找的特定类的完全限定名。

语法

2. MyClass.class

在类名后附加 .class 会引用代表该类的 Class 对象。当类名在编译时已知时，可以使用此方法。它经常与原始数据类型一起使用。

语法

3. obj.getClass()

`getClass()` 方法属于 Object 类。当使用它时，它会给出对象的实际类。当我们在程序运行时想要确定类类型时，它很有用。

语法

MyClass obj = new MyClass();
Class<?> c = obj.getClass();

方法

String toString()

该方法将 Class 对象转换为字符串，通过添加 "class" 或 "interface"，然后是空格，最后是对象所属类的完整名称。如果 Class 对象代表基本数据类型，则方法返回该类型的名称；否则，它返回 "void"。

语法

参数

返回值

返回当前类对象的字符串表示。

覆盖

该方法覆盖了 Object 类中的 toString 方法。

文件名: StringDemo.java

// Java program with updated variable names and print statements
public class StringDemo {

    public static void main(String args[]) {
        // Creating a String object
        String firstString = new String("Hello World");

        // Printing the string representation using toString()
        System.out.print("Output String 1: ");
        System.out.println(firstString.toString());

        // Creating another String object
        String secondString = new String("Welcome to javatpoint");

        // Printing the string representation using toString()
        System.out.print("Output String 2: ");
        System.out.println(secondString.toString());
    }
}

输出

Output String 1: Hello World
Output String 2: Welcome to javatpoint

Class<?> forName(String className)

它返回与给定字符串名称的类或接口关联的 Class 对象。

语法

参数

className: 一个字符串，表示要加载的类或接口的完全限定名。

返回值

返回与具有给定名称的类关联的 Class 对象。

异常: 该方法可能会抛出以下异常

LinkageError: 如果类链接失败，则会抛出此异常。
ExceptionInInitializerError: 如果此方法触发的初始化遇到错误，则会抛出此异常。
ClassNotFoundException: 如果找不到指定的类，则会抛出此异常。

文件名: ClassLoadingExample.java

public class ClassLoadingExample {

    public static void main(String[] args) throws ClassNotFoundException {
        // Fully qualified name of the class to load
        String className = "java.util.ArrayList";

        // Load the class dynamically
        Class<?> clazz = Class.forName(className);

        // Print the name of the loaded class
        System.out.println("Loaded Class Name: " + clazz.getName());
    }
}

输出

Loaded Class Name: java.util.ArrayList

Class<?> forName(String className,boolean initialize, ClassLoader loader)

该方法还提供了与给定字符串名称标识的类或接口关联的 Class 对象，并利用提供的类加载器。指定的类加载器负责加载类或接口。如果未指定 `loader` 参数或其为 null，则在初始化过程中（仅当 `initialize` 参数设置为 `true` 且类尚未经过初始化时）将通过引导类加载器加载该类。

语法

public static Class<?> forName(String className,boolean initialize, ClassLoader loader) throws ClassNotFoundException

参数

className: 一个字符串，表示要加载类的完全限定名。
initialize: 一个布尔值，指示是否应初始化该类。如果为 true，则初始化该类；如果为 false，则不初始化。
loader: 用于加载类的 ClassLoader 对象。如果为 null，则使用默认的系统类加载器。

返回值

检索与给定名称的类关联的 Class 对象。

抛出

LinkageError: 如果类链接失败，则发生此错误。
ExceptionInInitializerError: 如果此方法触发的初始化遇到错误，则出现此错误。
ClassNotFoundException: 如果找不到指定的类，则抛出此异常。

文件名: DynamicClassLoadingDemo.java

// Java program illustrating the use of forName() method
public class DynamicClassLoadingDemo {

    public static void main(String[] args) throws ClassNotFoundException {
        // Obtain the Class object for the current class
        Class currentClass = Class.forName("DynamicClassLoadingDemo");

        // Get the ClassLoader associated with the current class
        ClassLoader classLoader = currentClass.getClassLoader();

        // Using the forName method to dynamically load the String class with the provided ClassLoader
        Class loadedClass = Class.forName("java.lang.String", true, classLoader);

        // Display the representation of the loaded class
        System.out.print("Class represented by loadedClass: " + loadedClass.toString());
    }
}

输出

Class represented by loadedClass: class java.lang.String

T newInstance()

`newInstance()` 方法会创建一个由调用对象代表的类的新实例。它是一种无需显式使用 `new` 关键字即可动态实例化对象的方法。新实例的类型基于调用方法的对象的类型。请记住，此方法假定类有一个默认（无参数）构造函数，并且如果此条件不满足或出现其他实例化问题，它可能会抛出异常。

语法

类型参数

T: 表示将为其创建实例的类类型。

参数

不需要参数。

返回值

该对象代表类的新分配实例。

抛出

IllegalAccessException: 如果类或其零参数构造函数不可访问。
InstantiationException: 如果此 Class 代表一个抽象类、接口、数组类、原始类型或 void；或者如果类没有零参数构造函数；或者由于其他原因实例化失败。
ExceptionInInitializerError: 如果此方法引起的初始化失败。
SecurityException: 如果存在安全管理器 s。

boolean isInstance(Object obj)

该方法检查给定对象是否可以赋值给此 Class 代表的类型。它与 Java 中的 instanceof 运算符类似，用于验证指定对象是否与它所代表的类兼容。

语法

参数

obj: 要检查是否与 Class 对象所代表的类赋值兼容的对象。

返回值

boolean: 如果指定对象是 Class 对象所代表的类或接口的实例，则返回 true，否则返回 false。

文件名: BooleanExample.java

// Java program to demonstrate the isInstance() method
public class BooleanExample {
    public static void main(String[] args) throws ClassNotFoundException {
        // Returns the Class object for the class 
        // with the specified name 
        Class<?> stringClass = Class.forName("java.lang.String");

        // Sample strings
        String sampleString = "javatpoint";
        Double sampleDouble = 10.5;

        // Checking for class instance using the isInstance method
        boolean isStringInstance = stringClass.isInstance(sampleString);
        boolean isDoubleInstance = stringClass.isInstance(sampleDouble);

        // Displaying results
        System.out.println("Is sampleString an instance of String? : " + isStringInstance);
        System.out.println("Is sampleDouble an instance of String? : " + isDoubleInstance);
    }
}

输出

Is sampleString an instance of String? : true
Is sampleDouble an instance of String? : false

boolean isAssignableFrom(Class<?> cls)

boolean isAssignableFrom 方法用于检查一个类是否可以代替另一个类使用。如果当前对象所代表的类与指定的类 (`cls`) 相同，或者是指定类的超类或超接口，则返回 true。否则，返回 false。

语法

参数

cls: 要进行比较的类。

返回值

boolean: 如果当前 Class 对象所代表的类可以从指定的类 (cls) 赋值，则返回 true。否则，返回 false。

抛出

NullPointerException: 如果提供的 Class 参数为 null，则该方法将抛出 NullPointerException。

文件名: ExampleBoolean.java

public class ExampleBoolean extends Thread {
    public static void main(String[] args) throws ClassNotFoundException {
        // Returns the Class object for this class
        Class<?> myClass = ExampleBoolean.class;

        // Returns the Class object for the class with the specified name
        Class<?> threadClass = Class.forName("java.lang.Thread");
        Class<?> stringClass = Class.forName("java.lang.String");

        // isAssignableFrom method on threadClass
        // It checks whether the Thread class is assignable from ExampleBoolean
        boolean isThreadAssignable = threadClass.isAssignableFrom(myClass);

        // isAssignableFrom method on stringClass
        // It checks whether the String class is assignable from ExampleBoolean
        boolean isStringAssignable = stringClass.isAssignableFrom(myClass);

        System.out.println("Is ExampleBoolean assignable from Thread class? : " + isThreadAssignable);
        System.out.println("Is ExampleBoolean assignable from String class? : " + isStringAssignable);
    }
}

输出

Is ExampleBoolean assignable from Thread class? : true
Is ExampleBoolean assignable from String class? : false

boolean isInterface()

boolean isInterface() 方法用于确定 Class 对象所代表的类或接口是否为接口。

语法

返回值

boolean: 如果 Class 对象所代表的类或接口是接口，则返回 true。否则，返回 false。

文件名: booleanisInterface.java

public class booleanisInterface {
    public static void main(String[] args) {
        // Get the class object for String and Runnable
        Class<?> stringClass = String.class;
        Class<?> runnableClass = Runnable.class;

        // Check if String is an interface
        boolean isStringInterface = stringClass.isInterface();
        System.out.println("Is String an interface? : " + isStringInterface);

        // Check if Runnable is an interface
        boolean isRunnableInterface = runnableClass.isInterface();
        System.out.println("Is Runnable an interface? : " + isRunnableInterface);
    }
}

输出

Is String an interface? : false
Is Runnable an interface? : true

boolean isPrimitive()

boolean isPrimitive() 方法用于确定 Class 对象所代表的类是否为原始数据类型。

语法

返回值

boolean: 如果 Class 对象所代表的类是原始数据类型，则返回 true。否则，返回 false。

文件名: booleanisPrimitive.java

public class booleanisPrimitive {
    public static void main(String[] args) {
        // Get the class object for int and String
        Class<?> intClass = int.class;
        Class<?> stringClass = String.class;

        // Check if int is a primitive type
        boolean isIntPrimitive = intClass.isPrimitive();
        System.out.println("Is int a primitive type? : " + isIntPrimitive);

        // Check if String is a primitive type
        boolean isStringPrimitive = stringClass.isPrimitive();
        System.out.println("Is String a primitive type? : " + isStringPrimitive);
    }
}

输出

Is int a primitive type? : true
Is String a primitive type? : false

boolean isArray()

它用于确定 Class 对象是否代表一个数组类。如果类是数组类，则该方法返回 true，否则返回 false。

语法

参数

该方法不接受任何参数。

返回值

boolean: 如果类代表数组类，则返回 true；否则，返回 false。

文件名: ArrayCheckExample.java

public class ArrayCheckExample {
    public static void main(String[] args) {
        int numbers[] = new int[2];

        // Obtain the Class object for the array class of 'numbers'
        Class<?> arrayClass = numbers.getClass();

        // Obtain the Class object for the Test class
        Class<?> testClass = ArrayCheckExample.class;

        // Check if the classes represent array types

        // Using isArray method on the arrayClass
        boolean isArray1 = arrayClass.isArray();

        // Using the isArray method on the testClass
        boolean isArray2 = testClass.isArray();

        // Output the results in a clearer way
        System.out.println("The class represented by " + arrayClass.getName() + " is an array: " + isArray1);
        System.out.println("The class represented by " + testClass.getName() + " is an array: " + isArray2);
    }
}

输出

The class represented by [I is an array: true
The class represented by ArrayCheckExample is an array: false

boolean isAnonymousClass()

当且仅当当前类是匿名类时，该方法才返回 true。匿名类类似于局部类，主要区别在于它没有指定名称。

语法

参数

该方法不接受任何参数。

返回值

返回类型为 boolean，表示该方法返回 true/false 值。如果当前类是匿名的，则返回 true，否则返回 false。

文件名: AnonymousExample.java

import java.lang.*;
public class AnonymousExample {
   public static void main(String[] args) {
      // Creating an instance of the AnonymousExample class
      AnonymousExample myInstance = new AnonymousExample();

      // Obtaining the Class object associated with the instance
      Class<?> myClass = myInstance.getClass();

      // Retrieving the name of the class
      String className = myClass.getName();
      System.out.println("Class Name = " + className);
     
      // Checking if this class is an anonymous class
      boolean isAnonymous = myClass.isAnonymousClass();
      System.out.println("Is this an Anonymous Class? " + isAnonymous);
   }
}

输出

Class Name = AnonymousExample
Is this an Anonymous Class? false

boolean isLocalClass()

isLocalClass() 方法用于确定一个类是否在方法内部声明，从而使其成为局部类。如果类是局部的，则返回 true，否则返回 false。

语法

参数

该方法不接受任何参数。

返回类型为 boolean，表示该方法返回 true/false 值。如果类是局部类，则返回 true，否则返回 false。

文件名: LocalClassExample.java

import java.lang.*;
public class LocalClassExample {
   public static void main(String[] args) {

      // Creating an instance of the LocalClassExample class
      LocalClassExample myInstance = new LocalClassExample();
      
      // Obtaining the Class object associated with the instance
      Class myClass = myInstance.getClass();

      // Retrieving the name of the class
      String className = myClass.getName();
      System.out.println("Class Name = " + className);
     
      // Checking if and only if this class is a local class
      boolean isLocal = myClass.isLocalClass();
      System.out.println("Is this a LocalClass? " + isLocal);
   }
}

输出

Class Name = LocalClassExample
Is this a LocalClass? false

boolean isMemberClass()

isMemberClass() 方法是 Java 中 Class 类的一部分，用于确定该类是否代表一个成员类（非局部、非匿名）类。成员类是在另一个类或接口中直接定义的类。

语法

参数

该方法不接受任何参数。

返回类型为 boolean，表示该方法返回 true/false 值。如果该类代表一个成员类（非局部、非匿名）类，则返回 true，否则返回 false。

文件名: MemberClassExample.java

import java.lang.*;
public class MemberClassExample {
   public static void main(String[] args) {
      // Creating an instance of the MemberClassExample class
      MemberClassExample myInstance = new MemberClassExample();
      Class myClass = myInstance.getClass();

      // Retrieving the name of the class
      String className = myClass.getName();
      System.out.println("The class name is: " + className);
     
      // Checking if and only if this class is a member class
      boolean isMember = myClass.isMemberClass();
      System.out.println("Is this class a member class? " + isMember);
   }
}

输出

The class name is: MemberClassExample
Is this class a member class? false

boolean isEnum()

它用于确定 Class 对象是否代表一个枚举类型。

语法

参数

上述方法不接受任何参数。

返回值

boolean: 如果类代表枚举类型，则返回 true；否则，返回 false。

文件名: EnumCheckExample.java

// Java program to demonstrate the isEnum() method

// Enum definition with different values
enum TrafficLight {
    RED, YELLOW, GREEN;
}

public class EnumCheckExample {
    public static void main(String[] args) {
        // Obtain the Class object associated with TrafficLight (an enum class)
        Class<?> trafficLightClass = TrafficLight.class;

        // Obtain the Class object associated with the EnumCheckExample class
        Class<?> testClass = EnumCheckExample.class;

        // Checking if the classes are Enum classes using isEnum method
        boolean isEnum1 = trafficLightClass.isEnum();
        boolean isEnum2 = testClass.isEnum();

        // Output the results with modified print statements
        System.out.println(trafficLightClass.getSimpleName() + " is an Enum class: " + isEnum1);
        System.out.println(testClass.getSimpleName() + " is an Enum class: " + isEnum2);
    }
}

输出

TrafficLight is an Enum class: true
EnumCheckExample is an Enum class: false

boolean isAnnotation()

它用于确定 Class 对象是否代表一个注解类型。如果类是注解类型，则该方法返回 true，否则返回 false。

语法

参数

上述方法不接受任何参数。

返回值

boolean: 如果类代表注解类型，则返回 true；否则，返回 false。

文件名: AnnotationCheckExample.java

// Java program to demonstrate the isAnnotation() method

// Declaring an Annotation Type
@interface MyAnnotation {
    // Annotation element definitions (if any)
}

public class AnnotationCheckExample {
    public static void main(String[] args) throws ClassNotFoundException {
        // Obtain the Class object associated with MyAnnotation (an annotation)
        Class<?> annotationClass = MyAnnotation.class;

        // Obtain the Class object associated with the AnnotationCheckExample class
        Class<?> testClass = AnnotationCheckExample.class;

        // Checking if the classes are Annotation types using the isAnnotation method
        boolean isAnnotation1 = annotationClass.isAnnotation();
        boolean isAnnotation2 = testClass.isAnnotation();

        // Output the results with modified print statements
        System.out.println(annotationClass.getSimpleName() + " is an annotation type: " + isAnnotation1);
        System.out.println(testClass.getSimpleName() + " is an annotation type: " + isAnnotation2);
    }
}

输出

MyAnnotation is an annotation type: true
AnnotationCheckExample is an annotation type: false

String getName()

它用于获取 Class 对象所代表的类、接口、数组或原始类型的完全限定名。该方法返回一个包含名称的 String。

语法

参数

该方法不接受任何参数。

返回值

String: 它返回 Class 对象所代表的类或类型的完全限定名。

文件名: GetNameExample.java

public class GetNameExample {
    public static void main(String[] args) {
        // Obtain the Class object for the String class
        Class<?> stringClass = String.class;

        // Output the name using getName() method
        System.out.println("Name of class String: " + stringClass.getName());
    }
}

输出

Name of class String: java.lang.String

String getSimpleName()

getSimpleName() 方法属于 Java 中的 java.lang.Class 类，用于检索源代码中指定的底层类的名称。如果底层类是匿名的，则该方法返回一个空字符串。对于数组，简单名称是从组件类型派生的，后跟 "[]" 以表示数组。具体来说，对于具有匿名组件类型的数组，简单名称表示为 "[]"。

语法

参数

该方法不接受任何参数。

返回值

String: 它返回 Class 对象所代表的类或接口的简单名称。

文件名: GetSimpleNameExample.java

public class GetSimpleNameExample {
    public static void main(String[] args) {
        // Obtain the Class object for the String class
        Class<?> stringClass = String.class;

        // Obtain the Class object for the Integer class
        Class<?> integerClass = Integer.class;

        // Output the simple names using getSimpleName() method
        System.out.println("Simple name of class String: " + stringClass.getSimpleName());
        System.out.println("Simple name of class Integer: " + integerClass.getSimpleName());
    }
}

输出

Simple name of class String: String
Simple name of class Integer: Integer

ClassLoader getClassLoader()

它用于获取 Class 对象所代表的类或接口的类加载器。该方法返回加载该类或接口的 ClassLoader 对象。

语法

参数

该方法不接受任何参数。

返回值

ClassLoader: 它返回 Class 对象所代表的类或接口的类加载器。

抛出

SecurityException: getClassLoader() 方法可能会抛出 SecurityException，如果安全管理器限制了对相应类的类加载器的访问。

文件名: GetClassLoaderExample.java

public class GetClassLoaderExample {
    public static void main(String[] args) {
        // Obtain the Class object for the String class
        Class<?> stringClass = String.class;

        // Obtain the ClassLoader object using getClassLoader() method
        ClassLoader classLoader = stringClass.getClassLoader();

        // Output the class loader information
        System.out.println("Class loader for String class: " + classLoader);

        // Attempting to access the class loader for the current class
        Class<?> currentClass = GetClassLoaderExample.class;
        ClassLoader currentClassLoader = currentClass.getClassLoader();
        System.out.println("Class loader for current class: " + currentClassLoader);
    }
}

输出

Class loader for String class: null
Class loader for current class: jdk.internal.loader.ClassLoaders$AppClassLoader@5cb0d902

TypeVariable<Class<T>>[ ] getTypeParameters()

它用于获取一个 TypeVariable 对象数组，该数组表示泛型类或接口（由 Class 对象代表）声明的类型参数。

语法

参数

该方法不接受任何参数。

返回值

TypeVariable<Class<T>>[]: 它返回一个 TypeVariable 对象数组，表示泛型类或接口的类型参数。

抛出

GenericSignatureFormatError: 如果类或接口的泛型签名不遵循 Java 虚拟机 (JVM) 规范的规定格式。

文件名: TypeVariableDemo.java

import java.lang.reflect.TypeVariable;
import java.util.List;

public class TypeVariableDemo {

    public static void main(String[] args) throws Exception {
        // returns an array of TypeVariable objects for the List class
        TypeVariable[] typeParameters = List.class.getTypeParameters();

        // Output the name of the first type parameter
        System.out.println("Type parameter of List class: " + typeParameters[0].getName());
    }
}

输出

Type parameter of List class: E

Class<? super T> getSuperclass()

它用于获取 Class 对象，该对象代表 Class 对象所代表的类或接口的超类。如果此 Class 对象所代表的类是接口，则该方法返回 null。

语法

参数

该方法不接受任何参数。

返回值

Class<? super T>: 它返回 Class 对象，该对象代表 Class 对象所代表的类或接口的超类。

文件名: GetSuperclassExample.java

import java.lang.*;
class SuperClass {
    // super class
}
class SubClass extends SuperClass {
    // sub class
}
public class GetSuperclassExample {
    public static void main(String args[]) {
        SuperClass instance1 = new SuperClass();
        SubClass instance2 = new SubClass();
        Class<?> classInfo;
        // Get the class of instance1
        classInfo = instance1.getClass();
        System.out.println("Instance 1 is an object of type: " + classInfo.getName());
        // Get the superclass of the class represented by instance1
        classInfo = classInfo.getSuperclass();
        System.out.println("Superclass of Instance 1: " + classInfo.getName());

        // Get the class of instance2
        classInfo = instance2.getClass();
        System.out.println("Instance 2 is an object of type: " + classInfo.getName());

        // Get the superclass of the class represented by instance2
        classInfo = classInfo.getSuperclass();
        System.out.println("Superclass of Instance 2: " + classInfo.getName());
    }
}

输出

Instance 1 is an object of type: SuperClass
Superclass of Instance 1: java.lang.Object
Instance 2 is an object of type: SubClass
Superclass of Instance 2: SuperClass

Type getGenericSuperclass()

Type getGenericSuperclass() 方法检索代表实体（可以是类、接口、原始类型或 void）的直接超类的 Type，该实体由此 Class 实例封装。

语法

参数

该方法不接受任何参数。

返回值

Type: 它返回代表类或接口的泛型超类的 Type 对象。

抛出

GenericSignatureFormatError: 泛型类签名不符合 Java 虚拟机规范第 3 版中规定的格式。
TypeNotPresentException: 如果泛型超类引用了不存在的类型声明，则可能抛出 TypeNotPresentException。
MalformedParameterizedTypeException: 如果泛型超类引用了一个无法实例化或因任何原因而无法实例化的参数化类型。

文件名: GenericTypeDemo.java

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.ArrayList;

public class GenericTypeDemo {

    public static void main(String[] arguments) {

        // Get the superclass
        Type genericSuperclass = IntegerListClass.class.getGenericSuperclass();
        System.out.println(genericSuperclass);

        // Extract the actual type argument using ParameterizedType
        ParameterizedType parameterizedType = (ParameterizedType) genericSuperclass;
        Type actualTypeArgument = parameterizedType.getActualTypeArguments()[0];
        System.out.println(actualTypeArgument);
    }
}

class IntegerListClass extends ArrayList<Integer> {
    public IntegerListClass() {
        // No-argument constructor
    }
}

输出

java.util.ArrayList
class java.lang.Integer

Class<?>[] getInterfaces()

`java.lang.Class.getInterfaces()` 方法用于识别此对象所代表的类或接口所实现的接口。

语法

返回值

Class<?>[]: 它返回一个 Class 对象数组，代表类或接口实现的接口。

文件名: GetInterfacesExample.java

import java.lang.reflect.*;
public class GetInterfacesExample {
    public static void main(String[] args) {
        // Obtain the Class object for a specific class
        Class<?> myClass = String.class;

        // Get the interfaces using getInterfaces() method
        Class<?>[] interfaces = myClass.getInterfaces();

        // Output the names of the interfaces
        System.out.println("Interfaces implemented by " + myClass.getName() + ":");
        for (Class<?> interfaceClass : interfaces) {
            System.out.println(interfaceClass.getName());
        }
    }
}

输出

Interfaces implemented by java.lang.String:
java.io.Serializable
java.lang.Comparable
java.lang.CharSequence

Type[] getGenericInterfaces()

它用于获取 Type 对象数组，该数组代表当前 Class 对象所代表的类或接口实现的泛型接口。

语法

返回值

Type[]: 它返回一个 Type 对象数组，代表类或接口实现的泛型接口。

抛出

GenericSignatureFormatError 当泛型类签名不符合 Java 虚拟机规范第 3 版中指定的格式时发生。
TypeNotPresentException: 如果任何泛型超接口引用了不存在的类型声明，则抛出此异常。
MalformedParameterizedTypeException: 当任何泛型超接口引用了无法实例化的参数化类型时，抛出此异常。

文件名: GetGenericInterfacesExample.java

import java.lang.reflect.Type;

public class GetGenericInterfacesExample {
    public static void main(String[] args) throws ClassNotFoundException {
        // Returns the Class object for the class with the specified name
        Class<?> c1 = Class.forName("java.util.Set");

        // getGenericInterfaces() on c1
        // It returns the interfaces implemented by the Set interface
        Type[] c1GenericInterfaces = c1.getGenericInterfaces();

        System.out.println("Interfaces implemented by Set interface:");

        // Iterating through Set class interfaces
        for (Type type : c1GenericInterfaces) {
            System.out.println(type);
        }
    }
}

输出

Interfaces implemented by Set interface:
java.util.Collection

Package getPackage()

它用于检索当前 Class 对象所代表的类或接口的包。

语法

返回值

Package: 它返回代表类或接口的包的 Package 对象。

文件名: GetPackageExample.java

public class GetPackageExample {
    public static void main(String[] args) {
        // Obtain the Class object for a specific class
        Class<?> myClass = String.class;

        // Get the package using getPackage() method
        Package classPackage = myClass.getPackage();

        // Output the name of the package
        System.out.println("Package of " + myClass.getName() + ": " + classPackage.getName());
    }
}

输出

Package of java.lang.String: java.lang

Field[] getFields()

Java 中的 `getFields()` 方法是 `Field` 类的一部分，用于检索 `Field` 对象数组，这些对象代表特定类或接口的字段。

语法

参数

该方法不包含任何参数。

getFields() 的返回类型是 Field[]。它返回一个 Field 对象数组，代表类或接口的公共字段。

抛出

SecurityException: 如果存在安全管理器 s。

文件名: GetFieldsExample.java

import java.lang.reflect.Field;

public class GetFieldsExample {
    public static void main(String[] customArgs) throws SecurityException, ClassNotFoundException {
        // Returns the Class object for the class with the specified name
        Class<?> customClass = Class.forName("java.lang.Integer");

        // getFields method on customClass
        // It returns an array of fields of the Integer class
        Field[] customFields = customClass.getFields();

        System.out.println("Below are the fields of Integer class:");

        // Iterating through all fields of the Integer class
        for (Field customField : customFields) {
            System.out.println(customField);
        }
    }
}

输出

Below are the fields of Integer class:
public static final int java.lang.Integer.MIN_VALUE
public static final int java.lang.Integer.MAX_VALUE
public static final java.lang.Class java.lang.Integer.TYPE
public static final int java.lang.Integer.SIZE
public static final int java.lang.Integer.BYTES

Class<?>[ ] getClasses()

它用于获取 Class 对象数组，代表当前 Class 对象类（Class object class）的公共成员类和接口。

语法

该方法返回一个 Class<?> 对象数组，代表类的公共成员类和接口。

抛出

SecurityException: 如果存在安全管理器 s。

文件名: GetClassesExample.java

import java.lang.reflect.*;

public class GetClassesExample {
    public static void main(String[] args) {
        try {
            // Get the Class object for the current class (GetClassesExample)
            Class<?> thisClass = GetClassesExample.class;

            // Retrieve the public member classes of the class
            Class<?>[] classes = thisClass.getClasses();

            // Display information about each public member class
            System.out.println("Public Member Classes of GetClassesExample:");
            for (Class<?> cls : classes) {
                System.out.println(cls.getName());
            }
        } catch (SecurityException e) {
            e.printStackTrace();
        }
    }
}

输出

Public Member Classes of GetClassesExample:

Method[] getMethods()

它用于检索 Method 对象数组，这些对象反映当前 Class 对象所代表的类或接口的公共方法。它包括类本身及其超类和接口的公共方法。

语法

该方法返回 Method 对象数组，代表类或接口的公共方法。

抛出

SecurityException: 如果存在安全管理器 s。

文件名: GetMethodsExample.java

import java.lang.reflect.Method;

public class GetMethodsExample {
    public static void main(String[] args) {
        try {
            // Get the Class object for a specific class (e.g., MyClass)
            Class<?> myClass = Class.forName("MyClass");

            // Retrieve the public methods of the class
            Method[] methods = myClass.getMethods();

            // Display information about each public method
            System.out.println("Public Methods of MyClass:");
            for (Method method : methods) {
                System.out.println(method.getName());
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

class MyClass {
    // Public methods
    public void method1() {
    }

    public int method2(String param) {
        return 0;
    }
}

输出

Public Methods of MyClass:
method1
method2
wait
wait
wait
equals
toString
hashCode
getClass
notify
notifyAll

Constructor<?>[] getConstructors()

它用于检索 Constructor 对象数组，这些对象反映当前 Class 对象所代表的类或接口的所有公共构造函数。

语法

该方法返回 Constructor<?> 对象数组，代表类或接口的公共构造函数。

抛出

SecurityException: 如果存在安全管理器 s。

文件名: ConstructorsExample.java

import java.lang.reflect.Constructor;

public class ConstructorsExample {
    public static void main(String[] args) {
        try {
            // Get the Class object for a specific class (e.g., Boolean)
            Class<?> booleanClass = Class.forName("java.lang.Boolean");

            // Retrieve the public constructors of the class
            Constructor<?>[] constructors = booleanClass.getConstructors();

            // Display information about each public constructor
            System.out.println("Constructors of Boolean class:");
            for (Constructor<?> constructor : constructors) {
                System.out.println(constructor);
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

输出

Constructors of Boolean class:public java.lang.Boolean(boolean)
public java.lang.Boolean(java.lang.String)

Field getField(String fieldName)

它用于获取一个 Field 对象，该对象反映当前 Class 对象所代表的类或接口的指定公共成员字段。

语法

public Field getField(String fieldName) throws NoSuchFieldException, SecurityException

参数

fieldName: 字段的名称。

返回值

该方法返回一个 Field 对象，代表指定的公共字段。

抛出

NoSuchFieldException: 如果找不到或无法访问指定的字段名，则发生此异常。
NullPointerException: 当提供的字段名为空时，出现此异常。
SecurityException: 如果存在安全管理器，并且某些与包访问和定义相关的安全条件未满足，则可能抛出此异常。

文件名: ExampleGetField.java

// Java program demonstrating the use of the getField() method

import java.lang.reflect.Field;

public class ExampleGetField {
    public static void main(String[] args)
            throws SecurityException, ClassNotFoundException,
            NoSuchFieldException {
        // Obtains the Class object for the specified class name (java.lang.Integer)
        Class<?> classObj = Class.forName("java.lang.Integer");

        // Retrieves a public field named "MIN_VALUE" from the Integer class
        Field fieldObj = classObj.getField("MIN_VALUE");

        // Displays information about the public field in the Integer class with MIN_VALUE name
        System.out.println("Public field in Integer class with MIN_VALUE name:");
        System.out.println(fieldObj);
    }
}

输出

Public field in Integer class with MIN_VALUE name:
public static final int java.lang.Integer.MIN_VALUE

Method getMethod(String methodName,Class… parameterTypes)

该方法检索一个 `Method` 对象，提供有关当前 `Class` 对象所代表的类或接口的特定公共方法的全面反射详细信息。

语法

参数

methodName: 一个字符串，表示我们要检索的方法的名称。
parameterTypes: 可变数量的 Class 对象，表示方法的参数类型。

返回值

该方法返回由给定名称指定的类的方法对象。

抛出

NoSuchMethodException: 如果找不到具有指定名称的方法，则抛出此异常。
NullPointerException: 如果提供的调用的方法名称为 null，则抛出此异常。
SecurityException: 如果存在安全管理器 (s)，则抛出此异常。

文件名: ExampleMethodGetMethod.java

import java.lang.reflect.Method;

public class ExampleMethodGetMethod {
    public static void main(String[] args) throws NoSuchMethodException, SecurityException, ClassNotFoundException {
        // Obtain the Class object for the specified class name (for example, java.lang.String)
        Class<?> classObj = Class.forName("java.lang.String");

        // Retrieve the method named "length" with no parameters from the String class
        Method methodObj = classObj.getMethod("length");

        // Display information about the retrieved method
        System.out.println("Details of the 'length' method in the String class:");
        System.out.println("Method Name: " + methodObj.getName());
        System.out.println("Return Type: " + methodObj.getReturnType());
    }
}

输出

Details of the 'length' method in the String class:
Method Name: length
Return Type: int

Constructor<?> getConstructor(Class<?>… parameterTypes)

该方法获取一个 Constructor 对象，该对象代表当前 Class 对象所指示类的特定公共构造函数。parameterTypes 参数是一个 Class 对象数组，指定构造函数的参数类型，并按声明的顺序排列。

语法

public Constructor<?> getConstructor(Class<?>... parameterTypes) throws NoSuchMethodException,SecurityException

参数

parameterTypes: 一个 Class 对象数组，表示构造函数的正式参数类型，按声明顺序。

返回一个 Constructor 对象，该对象反映此 Class 对象所代表类的指定公共构造函数。

抛出

NoSuchMethodException: 如果找不到具有指定参数类型的构造函数，则抛出此异常。
SecurityException: 如果存在安全管理器，则抛出此异常。

文件名: ExampleConstructor.java

import java.lang.reflect.Constructor;

public class ExampleConstructor {
    public static void main(String[] args) throws Exception {
        // Obtain Class objects for Integer and String classes
        Class<?> integerClass = Integer.class;
        Class<?> stringClass = String.class;

        try {
            // Get a public constructor in the Integer class with a String parameter
            Constructor<?> constructor = integerClass.getConstructor(stringClass);

            // Display information about the retrieved constructor
            System.out.println("Constructor in Integer class with String parameter:");
            System.out.println(constructor);
        } catch (NoSuchMethodException e) {
            System.err.println("No such constructor found.");
        }
    }
}

输出

Constructor in Integer class with String parameter:
public java.lang.Integer(java.lang.String) throws java.lang.NumberFormatException

T cast(Object obj)

该方法将一个对象转换为此 `Class` 对象所指示的类或接口。

语法

参数

obj: 要转换的对象。

在将对象转换为泛型类型 T 后返回。结果类型 (T) 是根据调用该方法的上下文推断的。

文件名: ExampleTCast.java

import java.util.List;

public class ExampleTCast {
    public static void main(String[] args) {
        Object anyObject = "Hello, World!";
        
        // Using cast to dynamically cast anyObject to String
        String outputResult = String.class.cast(anyObject);

        // Display the result after casting
        System.out.println("Casting Result: " + outputResult);
    }
}

输出

Casting Result: Hello, World!

<U> Class<? extends U> asSubclass(Class<U> clazz)

该方法将此 Class 对象转换为代表指定类对象所代表的类的子类。

语法

参数

<U>: 一个泛型类型，表示目标类型。
clazz: 一个 Class 对象，表示目标类或接口。

返回值

Class<? extends U>: 该方法返回一个 Class 对象，表示指定的类或子类，确保它是目标类型 U 的子类。

抛出

ClassCastException: 如果当前 Class 对象实际上不代表子类（包括类本身）。

文件名: ExampleClassExtends.java

public class ExampleClassExtends {
    public static void main(String[] args) {
        // Create a Class object representing the Integer class
        Class<?> integerClass = Integer.class;

        // Attempt to cast the Integer class as a subclass of Number
        Class<? extends Number> numberSubclass = integerClass.asSubclass(Number.class);

        // Display the result
        System.out.println("Integer class cast as a subclass of Number: " + numberSubclass.getName());
    }
}

输出

Integer class cast as a subclass of Number: java.lang.Integer

下一主题Java 中的反向层序遍历

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

Java Conversion

Java Misc

Java 中的 java.lang.Class 类

Class 类的方法

示例

创建 Class 对象

方法

String toString()

Class<?> forName(String className)

Class<?> forName(String className,boolean initialize, ClassLoader loader)

T newInstance()

boolean isInstance(Object obj)

boolean isAssignableFrom(Class<?> cls)

boolean isInterface()

boolean isPrimitive()

boolean isArray()

boolean isAnonymousClass()

boolean isLocalClass()

boolean isMemberClass()

boolean isEnum()

boolean isAnnotation()

String getName()

String getSimpleName()

ClassLoader getClassLoader()

TypeVariable<Class<T>>[ ] getTypeParameters()

Class<? super T> getSuperclass()

Type getGenericSuperclass()

Class<?>[] getInterfaces()

Type[] getGenericInterfaces()

Package getPackage()

Field[] getFields()

Class<?>[ ] getClasses()

Method[] getMethods()

Constructor<?>[] getConstructors()

Field getField(String fieldName)

Method getMethod(String methodName,Class… parameterTypes)

Constructor<?> getConstructor(Class<?>… parameterTypes)

T cast(Object obj)

<U> Class<? extends U> asSubclass(Class<U> clazz)

相关帖子

Java Program to Find the Earliest Time When a Frog Can Jump to The Other Side of a River

DecimalFormat getMaximumIntegerDigits() method in Java

How do you swap two string variables without using third or temp variable in java

Java 获取泛型参数的类

Java JRE

Java 中的箭头运算符

Java Program to Find the Mean of Array Using Recursion

SortedSet addAll() method in Java with Examples

How many days required to learn Java

No Suitable Driver Found For JDBC

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器