Download the JDK
Search the Tutorials
Hide the TOC
Trail: The Reflection API
Lesson: Classes
Section: Sealing Packages in Extensions
Classes
Retrieving Class Objects
Examining Class Modifiers and Types
Discovering Class Members
Troubleshooting
Home Page > The Reflection API > Classes
Retrieving Class Objects

> The entry point for all reflection operations is `java.lang.Class`. With the exception of `java.lang.reflect.ReflectPermission`, none of the classes in `java.lang.reflect` have public constructors. To get to these classes, it is necessary to invoke appropriate methods on `Class`. There are several ways to get a `Class` depending on whether the code has access to an object, the name of class, a type, or an existing `Class`.

> ### Object.getClass()

> If an instance of an object is available, then the simplest way to get its `Class` is to invoke `Object.getClass()`. Of course, this only works for reference types which all inherit from `Object`. Some examples follow.

> >     Class c = "foo".getClass();

> Returns the `Class` for `String`

> >     Class c = System.console().getClass();

> There is a unique console associated with the virtual machine which is returned by the `static` method `System.console()`. The value returned by `getClass()` is the `Class` corresponding to `java.io.Console`.

> >     enum E { A, B }
> >     Class c = A.getClass();

> `A` is is an instance of the enum `E`; thus `getClass()` returns the `Class` corresponding to the enumeration type `E`.

> >     byte[] bytes = new byte[1024];
> >     Class c = bytes.getClass();

> Since arrays are `Objects`, it is also possible to invoke `getClass()` on an instance of an array. The returned `Class` corresponds to an array with component type `byte`.

> >     import java.util.HashSet;
> >     import java.util.Set;

> >     Set<String> s = new HashSet<String>();
> >     Class c = s.getClass();

> In this case, `java.util.Set` is an interface to an object of type `java.util.HashSet`. The value returned by `getClass()` is the class corresponding to `java.util.HashSet`.

> ### The .class Syntax

> If the type is available but there is no instance then it is possible to obtain a `Class` by appending `".class"` to the name of the type. This is also the easiest way to obtain the `Class` for a primitive type.

> >     boolean b;
> >     Class c = b.getClass();   // compile-time error

> >     Class c = boolean.class;  // correct

> Note that the statement `boolean.getClass()` would produce a compile-time error because a `boolean` is a primitive type and cannot be dereferenced. The `.class` syntax returns the `Class` corresponding to the type `boolean`.

> >     Class c = java.io.PrintStream.class;

> The variable `c` will be the `Class` corresponding to the type `java.io.PrintStream`.

> >     Class c = int[][][].class;

> The `.class` syntax may be used to retrieve a `Class` corresponding to a multi-dimensional array of a given type.

> ### Class.forName()

> If the fully-qualified name of a class is available, it is possible to get the corresponding `Class` using the static method `Class.forName()`. This cannot be used for primitive types. The syntax for names of array classes is described by `Class.getName()`. This syntax is applicable to references and primitive types.

> >     Class c = Class.forName("com.duke.MyLocaleServiceProvider");

> This statement will create a class from the given fully-qualified name.

> >     CLass cDoubleArray = Class.forName("[D");

> >     Class cStringArray = Class.forName("[[Ljava.lang.String;");

> The variable `cDoubleArray` will contain the `Class` corresponding to an array of primitive type `double` (i.e. the same as `double[].class`). The `cStringArray` variable will contain the `Class` corresponding to a two-dimensional array of `String` (i.e. identical to `String[][].class`).

> ### TYPE Field for Primitive Type Wrappers

> The `.class` syntax is a more convenient and the preferred way to obtain the `Class` for a primitive type; however there is another way to acquire the `Class`. Each of the primitive types and `void` has a wrapper class in `java.lang` that is used for boxing of primitive types to reference types. Each wrapper class contains a field named `TYPE` which is equal to the `Class` for the primitive type being wrapped.

> >     Class c = Double.TYPE;

> There is a class `java.lang.Double` which is used to wrap the primitive type `double` whenever an `Object` is required. The value of `Double.TYPE` is identical to that of `double.class`.

> >     Class c = Void.TYPE;

> `Void.TYPE` is identical to `void.class`.

> ### Methods that Return Classes

> There are several Reflection APIs which return classes but these may only be accessed if a `Class` has already been obtained either directly or indirectly.
> `Class.getSuperclass()`
>   Returns the super class for the given class.

>   >     Class c = javax.swing.JButton.class.getSuperclass();

>   The super class of `javax.swing.JButton` is `javax.swing.AbstractButton`.
> `Class.getClasses()`
>   Returns all the public classes, interfaces, and enums that are members of the class including inherited members.

>   >     Class<?>[] c = Character.class.getClasses();

>   `Character` contains two member classes `Character.Subset` and `Character.UnicodeBlock`.
> `Class.getDeclaredClasses()`
>   Returns all of the classes interfaces, and enums that are explicitly declared in this class.

>   >     Class<?>[] c = Character.class.getDeclaredClasses();

>   `Character` contains two public member classes `Character.Subset` and `Character.UnicodeBlock` and one private class `Character.CharacterCache`.
> `{` `Class` `, java.lang.reflect. {` `Field`, `Method`, `Constructor` `} }.getDeclaringClass()`
>   Returns the `Class` in which these members were declared. Anonymous classes will not have a declaring class but will have an enclosing class.

>   >     import java.lang.reflect.Field;

>   >     Field f = System.class.getField("out");
>   >     Class c = f.getDeclaringClass();

>   The field `out</code</a> is declared in `System`.

>   >     public class MyClass {
>   >         static Object o = new Object() { public void m() {} };
>   >         static Class<c> = o.getClass().getEnclosingClass();
>   >     }

>   The declaring class of the anonymous class defined by `o` is `null`.`
> `Class.getEnclosingClass()`
>   Returns the immediately enclosing class of the class.

>   >     Class c = Thread.State.class().getEnclosingClass();

>   The enclosing class of the enum `Thread.State` is `Thread`.

>   >     public class MyClass {
>   >         static Object o = new Object() { public void m() {} };
>   >         static Class<c> = o.getClass().getEnclosingClass();
>   >     }

>   The anonymous class defined by `o` is enclosed by `MyClass`.

Previous page: Classes
Next page: Examining Class Modifiers and Types