Java Class Metadata: Names, Modifiers, Hierarchy and Generics

Su Suriya Ravichandran Updated 18 Nov 2026
12 min read ·Lesson 238 of 306

Java class metadata is the information a Class object holds about a type: its names, its kind (class, interface, enum, record), its modifiers, its superclass and interfaces, its generic type arguments, its nested types, and the package and module it lives in.

Frameworks read this metadata constantly. A dependency injection container checks which interfaces a class implements, a JSON library reads generic types such as List<String>, and a test runner skips abstract classes. In Java Reflection API you used Class to reach fields, methods and constructors. This lesson covers the rest of what Class can tell you and ends with a small javap-style class inspector.


Java Class Names: getName, getSimpleName and getCanonicalName

A class has several names, and each method returns a different one. The difference shows up for nested classes, arrays, local classes and anonymous classes.

import java.util.Map;

public class ClassNames {

    static class Nested { }

    public static void main(String[] args) {
        Runnable anonymous = new Runnable() {
            public void run() { }
        };
        class LocalHelper { }

        Class<?>[] types = {String.class, Nested.class, Map.Entry.class, int[][].class,
                LocalHelper.class, anonymous.getClass(), int.class};

        System.out.printf("%-24s %-14s %-20s %s%n", "getName", "getSimpleName", "getCanonicalName", "getPackageName");
        for (Class<?> type : types) {
            System.out.printf("%-24s %-14s %-20s \"%s\"%n", type.getName(), "\"" + type.getSimpleName() + "\"",
                    type.getCanonicalName(), type.getPackageName());
        }
    }
}

Output:

getName                  getSimpleName  getCanonicalName     getPackageName
java.lang.String         "String"       java.lang.String     "java.lang"
ClassNames$Nested        "Nested"       ClassNames.Nested    ""
java.util.Map$Entry      "Entry"        java.util.Map.Entry  "java.util"
[[I                      "int[][]"      int[][]              "java.lang"
ClassNames$1LocalHelper  "LocalHelper"  null                 ""
ClassNames$1             ""             null                 ""
int                      "int"          int                  "java.lang"

How it works:

MethodReturnsUse it for
getName()The binary name used by the JVM, with $ for nested types and [I style for arraysClass.forName, logs, unique keys
getSimpleName()The name as written in source, empty for anonymous classesDisplay text
getCanonicalName()The name you would write in an import, or null if there is noneGenerating source code
getTypeName()A readable name, with int[][] style for arraysMessages and tooling
getPackageName()The package, or "" for the default packageGrouping and filtering
  • Map.Entry is nested, so its binary name uses $ (java.util.Map$Entry) while its canonical name uses . (java.util.Map.Entry).
  • Local and anonymous classes have no canonical name, because you cannot refer to them from outside the method. Their binary names get compiler-generated numbers such as ClassNames$1.
  • Only getName() output can be passed back to Class.forName. Primitives such as int have a name but no class file, so Class.forName("int") fails.

Java Class Metadata: Kind of Type and Modifiers

A Class object can represent a class, interface, enum, record, annotation, array or primitive. A family of isX() methods tells them apart, and getModifiers() returns the declaration's modifiers as an int bit mask.

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

interface Shape { }
enum Level { BEGINNER, ADVANCED }
record Point(int x, int y) { }
@interface Marker { }
abstract class Base { }
sealed interface Payment permits Card, Upi { }
final class Card implements Payment { }
non-sealed class Upi implements Payment { }

public class KindOfType {

    static String kind(Class<?> type) {
        if (type.isAnnotation()) return "annotation"; // check first: annotations are interfaces too
        if (type.isInterface()) return "interface";
        if (type.isEnum()) return "enum";
        if (type.isRecord()) return "record";
        if (type.isArray()) return "array";
        if (type.isPrimitive()) return "primitive";
        return "class";
    }

    public static void main(String[] args) {
        Class<?>[] types = {Shape.class, Level.class, Point.class, Marker.class, Base.class,
                Payment.class, Card.class, Upi.class, String[].class, double.class, List.class};

        for (Class<?> type : types) {
            System.out.printf("%-9s %-10s sealed=%-5s modifiers=[%s]%n", type.getSimpleName(), kind(type),
                    type.isSealed(), Modifier.toString(type.getModifiers()));
        }
    }
}

Output:

Shape     interface  sealed=false modifiers=[abstract interface]
Level     enum       sealed=false modifiers=[final]
Point     record     sealed=false modifiers=[final]
Marker    annotation sealed=false modifiers=[abstract interface]
Base      class      sealed=false modifiers=[abstract]
Payment   interface  sealed=true  modifiers=[abstract interface]
Card      class      sealed=false modifiers=[final]
Upi       class      sealed=false modifiers=[]
String[]  array      sealed=false modifiers=[public abstract final]
double    primitive  sealed=false modifiers=[public abstract final]
List      interface  sealed=false modifiers=[public abstract interface]

How it works:

  • isAnnotation() must be checked before isInterface(), because every annotation type is also an interface.
  • isSealed() (Java 17+) is true only for Payment. Card is final and Upi is non-sealed; non-sealed is a compile-time keyword and has no modifier bit, so it does not appear.
  • Interfaces and annotations always report abstract interface; List also shows public because it is declared public, while these sample types are package-private. Top-level enums and records report final. Arrays and primitives report public abstract final, a JVM convention meaning they can neither be subclassed nor created with a constructor.
  • Modifier also has single checks such as Modifier.isAbstract(mods), Modifier.isFinal(mods) and Modifier.isPublic(mods).
Methodtrue when the type is
isInterface()An interface or annotation type
isAnnotation()An annotation type
isEnum()An enum
isRecord()A record (Java 16+)
isSealed()A sealed class or interface (Java 17+)
isArray() / isPrimitive()An array type / int, double, void and the other primitives
isMemberClass() / isLocalClass() / isAnonymousClass()Nested in a class / declared in a method / unnamed
isSynthetic() / isHidden()Generated by the compiler / a hidden class such as a lambda's

Superclass and Interfaces: Walking the Class Hierarchy

getSuperclass() returns the direct parent class, and getInterfaces() returns the interfaces a type lists directly in its implements (or, for an interface, extends) clause. isAssignableFrom and isInstance are the reflective versions of instanceof.

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

interface Payable { }

class Employee implements Serializable { }

class Manager extends Employee implements Payable, Comparable<Manager> {
    public int compareTo(Manager other) {
        return 0;
    }
}

public class Hierarchy {
    public static void main(String[] args) {
        Class<?> type = Manager.class;

        System.out.print("Superclass chain: ");
        for (Class<?> current = type; current != null; current = current.getSuperclass()) {
            System.out.print(current.getSimpleName() + (current.getSuperclass() != null ? " -> " : "\n"));
        }

        System.out.println("Direct interfaces: "
                + Arrays.stream(type.getInterfaces()).map(Class::getSimpleName).toList());
        System.out.println("Interface superclass: " + Payable.class.getSuperclass());

        System.out.println("Employee.isAssignableFrom(Manager): " + Employee.class.isAssignableFrom(Manager.class));
        System.out.println("Manager.isAssignableFrom(Employee): " + Manager.class.isAssignableFrom(Employee.class));
        System.out.println("Serializable.isInstance(new Manager()): " + Serializable.class.isInstance(new Manager()));
        System.out.println("List.isAssignableFrom(ArrayList): " + List.class.isAssignableFrom(ArrayList.class));
    }
}

Output:

Superclass chain: Manager -> Employee -> Object
Direct interfaces: [Payable, Comparable]
Interface superclass: null
Employee.isAssignableFrom(Manager): true
Manager.isAssignableFrom(Employee): false
Serializable.isInstance(new Manager()): true
List.isAssignableFrom(ArrayList): true

How it works:

  • The loop follows getSuperclass() until it returns null, which happens after Object. Interfaces, primitives and Object itself all return null.
  • getInterfaces() lists only Payable and Comparable. Serializable is not there, because Manager inherits it from Employee rather than declaring it.
  • A.isAssignableFrom(B) asks "can a B be stored in a variable of type A?". It is the class-to-class form of instanceof, while A.isInstance(object) works on an object.

Reading Generic Type Information

Because of type erasure, an ArrayList<String> object does not know it holds strings. But generic types written in declarations, such as extends ArrayList<String> or implements Function<String, Double>, are stored in the class file and can be read with the getGenericX methods.

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

class CourseList extends ArrayList<String> { }

class PriceParser implements Function<String, Double> {
    public Double apply(String text) {
        return Double.parseDouble(text);
    }
}

public class GenericMetadata {
    public static void main(String[] args) {
        System.out.println("getSuperclass():        " + CourseList.class.getSuperclass());

        Type generic = CourseList.class.getGenericSuperclass();
        System.out.println("getGenericSuperclass(): " + generic);

        ParameterizedType parameterized = (ParameterizedType) generic;
        System.out.println("raw type: " + parameterized.getRawType().getTypeName()
                + ", type argument: " + parameterized.getActualTypeArguments()[0].getTypeName());

        ParameterizedType function = (ParameterizedType) PriceParser.class.getGenericInterfaces()[0];
        Type[] arguments = function.getActualTypeArguments();
        System.out.println("Function input = " + arguments[0].getTypeName()
                + ", output = " + arguments[1].getTypeName());

        ArrayList<Integer> plainList = new ArrayList<>();
        System.out.println("Runtime list type parameter: " + plainList.getClass().getTypeParameters()[0]);
    }
}

Output:

getSuperclass():        class java.util.ArrayList
getGenericSuperclass(): java.util.ArrayList<java.lang.String>
raw type: java.util.ArrayList, type argument: java.lang.String
Function input = java.lang.String, output = java.lang.Double
Runtime list type parameter: E

How it works:

  • getSuperclass() returns the erased ArrayList. getGenericSuperclass() returns a Type that keeps <String>.
  • When the type is generic, that Type is a ParameterizedType. getRawType() gives ArrayList and getActualTypeArguments() gives String.
  • getGenericInterfaces() works the same way for implements clauses, revealing Function<String, Double>.
  • plainList was created with new ArrayList<>(), which is not a declaration of a subclass, so only the type variable E is available. The Integer exists only in the source code.

Note: This is why libraries such as Jackson and Gson ask you to write new TypeReference<List<Course>>() { }. The { } creates an anonymous subclass, and its generic superclass carries List<Course> into the runtime.


Enum, Record, Sealed and Nested Type Metadata

Special kinds of types have their own metadata methods.

import java.lang.reflect.RecordComponent;
import java.util.Arrays;

public class MemberMetadata {

    enum Status { DRAFT, PUBLISHED, ARCHIVED }

    record Lesson(int number, String title, Status status) { }

    sealed interface Result permits Result.Ok, Result.Failed {
        record Ok(String value) implements Result { }
        record Failed(String reason) implements Result { }
    }

    public static void main(String[] args) {
        System.out.println("Enum constants: " + Arrays.toString(Status.class.getEnumConstants()));

        for (RecordComponent component : Lesson.class.getRecordComponents()) {
            System.out.println("Record component: " + component.getType().getSimpleName() + " "
                    + component.getName() + " via " + component.getAccessor().getName() + "()");
        }

        System.out.println("Permitted: " + Arrays.stream(Result.class.getPermittedSubclasses())
                .map(Class::getSimpleName).toList());
        System.out.println("Lesson declared in: " + Lesson.class.getDeclaringClass().getSimpleName());
        System.out.println("Nested types: " + Arrays.stream(MemberMetadata.class.getDeclaredClasses())
                .map(Class::getSimpleName).sorted().toList());
        System.out.println("String enum constants: " + String.class.getEnumConstants());
    }
}

Output:

Enum constants: [DRAFT, PUBLISHED, ARCHIVED]
Record component: int number via number()
Record component: String title via title()
Record component: Status status via status()
Permitted: [Ok, Failed]
Lesson declared in: MemberMetadata
Nested types: [Lesson, Result, Status]
String enum constants: null

How it works:

  • getEnumConstants() returns the enum's values in declaration order, or null for a type that is not an enum.
  • getRecordComponents() returns the components in declaration order. Each one knows its type, name and generated accessor method.
  • getPermittedSubclasses() lists the classes allowed by a sealed ... permits clause. Pattern-matching libraries use it to check that every case is handled.
  • getDeclaringClass() returns the class a member type is nested in, and getDeclaredClasses() returns all member types of a class.

Package, Module and Class Loader Metadata

Every class belongs to a package, a module and a class loader. This metadata tells you where a class came from.

public class RuntimeMetadata {
    public static void main(String[] args) {
        Class<?>[] types = {RuntimeMetadata.class, String.class, java.sql.Connection.class};

        for (Class<?> type : types) {
            Module module = type.getModule();
            ClassLoader loader = type.getClassLoader();
            System.out.printf("%-16s package=%-11s module=%-10s loader=%s%n",
                    type.getSimpleName(),
                    "\"" + type.getPackageName() + "\"",
                    module.isNamed() ? module.getName() : "(unnamed)",
                    loader == null ? "bootstrap" : loader.getName());
        }
    }
}

Output:

RuntimeMetadata  package=""          module=(unnamed)  loader=app
String           package="java.lang" module=java.base  loader=bootstrap
Connection       package="java.sql"  module=java.sql   loader=platform

How it works:

  • Your own class lives in the default package ("") and the unnamed module, the module for everything on the classpath.
  • String lives in the named module java.base. Its class loader is the bootstrap loader, which Java represents as null.
  • java.sql.Connection is loaded by the platform loader in module java.sql, and your classes by the app loader. Modules are covered in Java Modules.

Real-World Example: A javap-Style Class Inspector

The JDK tool javap prints a summary of a compiled class. This example builds a small version with class metadata. It also shows a detail that surprises many developers: the compiler adds hidden bridge methods for generics, and tools must filter them out.

import java.io.Serializable;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.Type;
import java.util.Arrays;
import java.util.Comparator;
import java.util.LinkedHashSet;
import java.util.Set;
import java.util.stream.Collectors;

interface Billable {
    double total();
}

abstract class Product implements Comparable<Product> {
    protected final String sku;

    protected Product(String sku) {
        this.sku = sku;
    }
}

final class OnlineCourse extends Product implements Billable, Serializable {
    public static final double GST_RATE = 0.18;
    private final double basePrice;
    private int enrolled;

    public OnlineCourse(String sku, double basePrice) {
        super(sku);
        this.basePrice = basePrice;
    }

    OnlineCourse(String sku) {
        this(sku, 999.0);
    }

    public double total() {
        return basePrice * (1 + GST_RATE);
    }

    public void enroll(int seats) {
        enrolled += seats;
    }

    public int compareTo(Product other) {
        return sku.compareTo(other.sku);
    }

    private static String format(double amount) {
        return String.format("%.2f", amount);
    }
}

class ClassInspector {

    static String simple(Type type) {
        return type.getTypeName().replaceAll("\\b[a-z]\\w*\\.", ""); // drop package prefixes
    }

    static void collectInterfaces(Class<?> type, Set<String> found) {
        for (Class<?> current = type; current != null; current = current.getSuperclass()) {
            for (Class<?> anInterface : current.getInterfaces()) {
                found.add(anInterface.getSimpleName());
                collectInterfaces(anInterface, found);
            }
        }
    }

    static String params(Class<?>[] types) {
        return Arrays.stream(types).map(Class::getSimpleName).collect(Collectors.joining(", "));
    }

    static void describe(Class<?> type) {
        // 1. declaration line
        String kind = type.isInterface() ? "interface" : type.isRecord() ? "record" : type.isEnum() ? "enum" : "class";
        String modifiers = Modifier.toString(type.getModifiers() & ~Modifier.INTERFACE);
        String implementsList = Arrays.stream(type.getGenericInterfaces())
                .map(ClassInspector::simple).collect(Collectors.joining(", "));
        System.out.println(modifiers + " " + kind + " " + type.getSimpleName()
                + " extends " + simple(type.getGenericSuperclass())
                + " implements " + implementsList + " {");

        // 2. every interface, including inherited ones
        Set<String> allInterfaces = new LinkedHashSet<>();
        collectInterfaces(type, allInterfaces);
        System.out.println("  // all interfaces: " + allInterfaces);

        // 3. fields
        Field[] fields = type.getDeclaredFields();
        Arrays.sort(fields, Comparator.comparing(Field::getName));
        for (Field field : fields) {
            System.out.println("  " + Modifier.toString(field.getModifiers()) + " "
                    + field.getType().getSimpleName() + " " + field.getName() + ";");
        }

        // 4. constructors
        Constructor<?>[] constructors = type.getDeclaredConstructors();
        Arrays.sort(constructors, Comparator.comparing(Constructor::getParameterCount));
        for (Constructor<?> constructor : constructors) {
            String access = Modifier.toString(constructor.getModifiers());
            System.out.println("  " + (access.isEmpty() ? "" : access + " ") + type.getSimpleName()
                    + "(" + params(constructor.getParameterTypes()) + ");");
        }

        // 5. methods, without compiler-generated bridges
        Method[] methods = type.getDeclaredMethods();
        Arrays.sort(methods, Comparator.comparing(Method::getName)
                .thenComparing(method -> params(method.getParameterTypes())));
        int bridges = 0;
        for (Method method : methods) {
            if (method.isBridge()) {
                bridges++;
                continue;
            }
            System.out.println("  " + Modifier.toString(method.getModifiers()) + " "
                    + method.getReturnType().getSimpleName() + " " + method.getName()
                    + "(" + params(method.getParameterTypes()) + ");");
        }
        System.out.println("  // skipped " + bridges + " bridge method(s)");
        System.out.println("}");
    }
}

public class Inspector {
    public static void main(String[] args) {
        ClassInspector.describe(OnlineCourse.class);
    }
}

Output:

final class OnlineCourse extends Product implements Billable, Serializable {
  // all interfaces: [Billable, Serializable, Comparable]
  public static final double GST_RATE;
  private final double basePrice;
  private int enrolled;
  OnlineCourse(String);
  public OnlineCourse(String, double);
  public int compareTo(Product);
  public void enroll(int);
  private static String format(double);
  public double total();
  // skipped 1 bridge method(s)
}

How it works:

  1. Declaration line. getModifiers() gives final, the kind comes from the isX() checks, and getGenericSuperclass() and getGenericInterfaces() supply the extends and implements parts. The simple helper strips package prefixes such as java.io. with a regular expression.
  2. All interfaces. getInterfaces() only returns direct interfaces, so collectInterfaces walks up the superclass chain and into super-interfaces. That is how it finds Comparable, which OnlineCourse inherits from Product.
  3. Fields and constructors. getDeclaredFields() and getDeclaredConstructors() return every access level. The package-private constructor has no modifier keyword at all. Both arrays are sorted because their order is not guaranteed.
  4. Bridge methods. Product implements Comparable<Product>, whose erased method is compareTo(Object). To make that work, the compiler secretly adds a compareTo(Object) method to OnlineCourse that calls compareTo(Product). getDeclaredMethods() returns it, and isBridge() lets the inspector skip it.
  5. Private static helpers. format appears with private static, showing that reflection sees every declared member, not just the public API.

The next lesson, Java Dynamic Objects, uses this metadata to decide which class to instantiate and how, building objects from names read at runtime.

0 Comments

Reviewed before they appear

No comments yet.

Java
Java Introduction Java Features Java Syntax Java Comments Java Statements Java Output Java Variables Java Data Types Java Type Casting Java Operators Java Strings Java Numbers Java Math Java Booleans Java User Input Java Conditions Java If Else Java Switch Java While Loop Java For Loop Java Break Java Continue Java Arrays Java Methods Java Parameters Java Return Values Java Scope Java Recursion Install Java Install JDK Java IDEs Java JDK Java JRE Java JVM Java Compiler Java File Compile Java Run Java JShell Basics Java Packages Java OOP Java Classes Java Objects Class Methods Constructors Constructor Overload this Keyword static Keyword final Keyword Encapsulation Inheritance Polymorphism Abstraction Access Modifiers super Keyword Method Overload Method Override Instanceof Operator Nested Classes Inner Classes Anonymous Classes Enums Records Array Basics Array Length Loop Arrays Multidimensional Arrays Array Copy Array Sorting Array Search ArrayList LinkedList HashSet TreeSet HashMap TreeMap Queue Interface Deque Interface Stack Class Iterator List Interface Set Interface Map Interface Collections Class Comparable Comparator Generics Basics Generic Classes Generic Methods Wildcards String Basics String Length String Methods String Concatenation String Compare String Search String Replace String Split String Format StringBuilder StringBuffer Text Blocks Regular Expressions Number Types Integer Class Float Class Double Class BigInteger BigDecimal Math Class Random Numbers Number Format Date Basics LocalDate LocalTime LocalDateTime ZonedDateTime Date Formatting Date Parsing Period Class Duration Class Java Instant Class Java Exception Basics Java try...catch Java Multiple Catch Blocks Java finally Block Java throw Keyword Java throws Keyword Java Checked Exceptions Java Unchecked Exceptions Java Custom Exceptions Java try-with-resources Java Exception Chaining Java File Basics Java Create Files Java Read Files Java Write Files Java Delete Files Java File Paths Java File Class Java BufferedReader Java BufferedWriter Java FileInputStream Java FileOutputStream Java Object Streams Java Directory Handling Java NIO Basics Java Files API Java Input Java Scanner Class Java Console Input Java PrintStream Java InputStream Java OutputStream Java Reader Class Java Writer Class Java Buffered Streams Java Data Streams Java Generics Introduction Java Generic Types Java Generic Methods Java Bounded Types Java Wildcards Java Type Erasure Java Generic Interfaces Java Generic Collections Java Lambda Basics Java Lambda Syntax Java Functional Interfaces Java Method References Java Stream API Java Stream Creation Java Stream Filter Java Stream Map Java Stream Reduce Java Stream Sort Java Stream Collect Java Collectors Class Java Optional Class Java Parallel Streams Java Threads: Thread Basics Create a Thread in Java Java Thread Class Java Runnable Interface Java Thread States Java Thread Sleep Java Thread Join Java Thread Priority Java Synchronization Java Thread Safety Java Race Conditions Java Deadlocks Java Executor Service Java Thread Pools Java Callable Interface Java Future Interface Java CompletableFuture Java Concurrent Collections Java Atomic Classes Java Virtual Threads Java Networking Basics Java URL Class Java URI Class Java HttpClient Java HTTP Requests Java HTTP Responses Java Socket Basics Java ServerSocket Java DatagramSocket Java WebSocket Basics Java JDBC Basics Java JDBC Setup Java Database Connection Java JDBC Connection Interface Java JDBC Statement Java PreparedStatement Java ResultSet Java JDBC CRUD Operations Java JDBC Transactions Java JDBC Batch Update Java Connection Pooling with HikariCP Java JPA Basics: Entities, EntityManager and JPQL Java Hibernate Basics: SessionFactory, Session and HQL Package in Java: Basics Explained with Examples Create Package in Java: Step-by-Step Guide with Examples Import Package in Java: The import Statement Explained Access Control in Java: Packages, Classes and Members JAR File in Java: Create, Run and Inspect JAR Files Java Modules: Introduction to the Java Module System module-info in Java: Every Module Directive Explained Java Module Path: How --module-path Finds Your Modules Java Classpath: How -cp and CLASSPATH Find Your Classes Java Annotations: Basics of @ Metadata in Java Java Built-in Annotations: @Override, @Deprecated and More Java Custom Annotations: Create Your Own @interface Java Annotation Targets: @Target and ElementType Explained Java Reflection API: Inspect and Use Classes at Runtime Java Class Metadata: Names, Modifiers, Hierarchy and Generic Java Dynamic Objects: Create Objects Dynamically With Reflec Java Dynamic Proxy: Intercept Method Calls With Proxy and In Java Security Java Secure Coding Java Password Hashing Java Input Validation Java Cryptography Basics Java KeyStore Basics Java TLS Basics Java SecureRandom Java JUnit Basics Java JUnit Test Methods JUnit Assertions JUnit Test Fixtures JUnit Parameterized Tests Mockito in Java Java Mock Objects Java Integration Testing Java Code Coverage Maven in Java Create a Maven Project in Java Maven Dependencies Maven Plugins Gradle in Java Gradle Build Gradle Dependencies Build Executable JAR in Java Build WAR File in Java HTTP Basics in Java Java Servlet Basics Servlet Lifecycle in Java HttpServletRequest in Java HttpServletResponse in Java JSP in Java JSTL in JSP REST API in Java JSON in Java Java Web Application Spring Framework Basics Spring Boot Tutorial Spring MVC Spring Data JPA Spring Security Spring Boot REST API Jakarta EE Basics Java Deployment JAR Deployment Java WAR Deployment Run Java as a Service Docker Java: Dockerize a Java Application Java Environment Variables and Configuration Java Logging Basics Java Production Setup Java JVM Options Java JVM Monitoring Java Hello World App Java Calculator App Java Number Guess Game Java Student Manager Java Library System Java Bank App Java Todo App Java File Manager Java Quiz App Java REST API Project Java Chat Server Java Employee Manager Java E-commerce API
Ask about this post
AI Ask about this post

Ask questions about Java Class Metadata: Names, Modifiers, Hierarchy and Generics and get answers drawn from it.

Signed-in readers only.