1Z0-829 Java Platform Overview and Packaging — 15 Questions

Question 1

A Java 17 application is deployed on a server. The application uses modules but one required module is missing from the module path. Which exception will be thrown at startup?

Accepted Answer

ModuleNotFoundException. None of the listed exceptions are correct. When a required module is missing from the module path during startup in Java 17, the module system throws `java.lang.module.FindException`, not `ModuleNotFoundException`. `ExceptionInInitializerError` occurs during static initialization, `NoClassDefFoundError` when a class is missing at runtime, and `ClassNotFoundException` at class loading. `ModuleNotFoundException` is not a standard Java exception.

Answer

ExceptionInInitializerError

Answer

NoClassDefFoundError

Answer

ClassNotFoundException

Question 2

A Java 17 application is packaged as a JAR with a Main-Class manifest entry. The JAR is run using 'java -jar app.jar'. However, the application throws a NoClassDefFoundError for a class that is inside the JAR. What is the most likely cause?

Accepted Answer

The class is not exported from its module. A NoClassDefFoundError occurs when a class was available at compile time but cannot be loaded at runtime. In a modular Java 17 application, if the class is in a package that is not exported by its module (Option A), classes outside that module cannot access it, leading to the error despite the class being present in the JAR. Additionally, if the JAR file is corrupt (Option C) – for example, due to truncation or CRC mismatch – the JVM cannot read the class bytes properly, also causing NoClassDefFoundError. Therefore, both A and C are common causes. Option B (incorrect Main-Class) would cause the application not to start or a different error. Option D (classpath not set) is irrelevant when using '-jar' as the JVM ignores the classpath.

Answer

The Main-Class manifest entry is incorrect

Answer

The classpath is not set

Question 3

A developer receives the above error when running a modular Java application. What is the most likely cause?

Accepted Answer

The module 'com.example.app' is not on the module path.. When a modular Java application throws an error indicating that a module cannot be found, the most common cause is that the module's JAR or directory is not present on the module path. The module path is specified using the `--module-path` option (or `-p`) when launching the application with `java --module`. If `com.example.app` is not on that path, the module system cannot resolve it, leading to a `ModuleNotFoundException` or similar error.

Answer

The module-info.java has a syntax error.

Answer

The JRE version is too old.

Answer

The main class is misspelled.

Question 4

A company runs a Java 17 microservice that reads stock market data from a WebSocket and processes it. The application is packaged as an executable JAR using Maven Shade Plugin. Recently, after a dependency update, the application started throwing 'javax.net.ssl.SSLHandshakeException: PKIX path building failed' when connecting to the WebSocket. The security team insists that no certificates should be imported into the default truststore. The application already includes a custom truststore file 'certs.jks' in the resources folder. The developer had been loading it programmatically but the new dependency uses a different SSL context. The application must trust the WebSocket server without modifying JVM defaults. Which action should be taken?

Accepted Answer

Set the system property 'javax.net.ssl.trustStore' to the path of 'certs.jks' and 'javax.net.ssl.trustStorePassword' to its password.. Setting the system properties 'javax.net.ssl.trustStore' and 'javax.net.ssl.trustStorePassword' overrides the default JVM truststore globally for all SSL contexts within the application. This allows the custom 'certs.jks' file to be used without modifying the JVM's default truststore, satisfying the security team's requirement. The new dependency causing the issue likely uses the default SSL context, which will now pick up the custom truststore via these system properties.

Answer

Add the certificate to the default truststore using keytool and restart the application.

Answer

Use the jlink tool to create a custom runtime image that includes the certificate.

Answer

Create a custom TrustManager that bypasses all certificate validation.

Question 5

Which TWO statements are true about the Java Platform Module System (JPMS) introduced in Java 9?

Accepted Answer

The module declaration is stored in a file named module-info.java.. Option B is correct because JPMS module declarations are written in a source file named module-info.java, which is compiled into module-info.class and placed at the root of the module's artifact. Option C is correct because JPMS enforces strong encapsulation: a package inside a module is only accessible to other modules if the module explicitly exports it with an exports directive in module-info.java. Option A is incorrect because the module path is searched before the class path during type resolution, not after. Option D is incorrect because an automatic module is a JAR on the module path that lacks a module-info.class; its name is derived from the JAR filename or manifest. Option E is incorrect because a named module cannot access the unnamed module unless it explicitly reads it, and even then access is limited to exported packages on the class path.

Answer

The module path is searched after the class path when resolving types.

Answer

An automatic module is one that has a module-info.class file at its root.

Answer

A named module can access the unnamed module without any explicit declaration.

Question 6

A developer runs the command above on a JAR file. Which statement accurately describes the module myapp?

Accepted Answer

The module exports com.myapp.internal to the module myapp.tests only.. The command `java --describe-module myapp` outputs the module descriptor, which includes `exports com.myapp.internal to myapp.tests`. This indicates that the module `myapp` exports the package `com.myapp.internal` specifically to the module `myapp.tests` only, not to all modules. The `exports ... to` syntax restricts access to a qualified list of modules.

Answer

The module opens com.myapp.internal for deep reflection to all modules.

Answer

The module provides a service implementation.

Answer

The module requires java.base explicitly; it is not mandated.

Question 7

A team is developing a large enterprise application using Java 17. The application consists of multiple modules: core (provides logging and configuration), services (business logic), and web (REST endpoints). The modules are packaged as separate JAR files and deployed on a server. During runtime, the web module throws a java.lang.ClassNotFoundException for a class that is part of the core module. The core module's module-info.java exports the package containing the missing class. The web module's module-info.java requires core. However, the services module also needs the same class but uses a different version of it, causing conflicts. The team decides to use the class path for the conflicting package and the module path for the rest. They add the conflicting JAR to the class path and keep the other JARs on the module path. After this change, the web module still cannot find the class, but the services module works fine. What is the most likely cause of the issue?

Accepted Answer

The web module is a named module and cannot access classes from a split package that is also in the unnamed module.. When a named module (the web module) is on the module path, it cannot access classes from the unnamed module (the class path) if those classes belong to a package that is also exported by another named module on the module path. This creates a split package, which is forbidden by the Java module system. The core module exports the package, so the web module cannot load the class from the class path JAR, resulting in ClassNotFoundException.

Answer

The services module is using an automatic module, which automatically reads the unnamed module, while the web module is a named module that does not.

Answer

The class path is not scanned for JAR files unless the module path is empty.

Answer

The core module's module-info.java does not export the package to the web module; it only exports it to all modules.

Question 8

Given the output of `java --list-modules` from a Java 17 installation, which module is NOT included by default when using the `--release 17` flag with `javac`?

Accepted Answer

jdk.incubator.foreign. The `--release 17` flag restricts `javac` to the standard Java SE 17 API, which does not include incubator modules like `jdk.incubator.foreign`. Incubator modules are preview features that are not part of the Java SE specification and must be explicitly added with `--add-modules`.

Answer

jdk.jfr

Answer

java.net.http

Answer

java.sql

Question 9

A development team is working on a Java 17 application that must be packaged as a custom runtime image for deployment on a Linux server without a JDK installed. The application uses `java.base`, `java.logging`, and `java.sql` modules, and also requires the `jdk.crypto.cryptoki` module for hardware security module (HSM) integration. The team wants to minimize the image size while ensuring all necessary modules are included. They run `jlink --add-modules java.base,java.logging,java.sql,jdk.crypto.cryptoki --output myapp-runtime`. The resulting image runs the application but fails at startup with a `ClassNotFoundException` for `javax.crypto.spec.SecretKeySpec`. Which action should the team take to resolve the issue?

Accepted Answer

Add `--bind-services` to the jlink command to include service provider modules.. The `jdk.crypto.cryptoki` module is a service provider module that provides cryptographic services via the Java Cryptography Architecture (JCA). When using `jlink`, service provider modules are not automatically included unless `--bind-services` is specified, because `jlink` only includes modules directly referenced in the module graph. The `javax.crypto.spec.SecretKeySpec` class is part of `java.base`, but the actual provider implementation that makes it available at runtime is in `jdk.crypto.cryptoki`; without `--bind-services`, the service linkage is missing, causing the `ClassNotFoundException`.

Answer

Manually add the `java.security.jgss` module to the `--add-modules` list.

Answer

Use the `--list-modules` option with jlink to verify which modules are included, then add any missing ones.

Answer

Add `ALL-MODULE-PATH` to the `--add-modules` list to include all available modules.

Question 10

Match each Java 17 feature to its description.

Accepted Answer

Sealed Classes: A feature that allows a class or interface to restrict which other classes or interfaces may extend or implement it.. These are key features introduced or enhanced in recent Java versions including 17.

Answer

Enhanced NullPointerExceptions: A feature that allows a class to restrict which subclasses can implement it.

Answer

Switch Expressions: A preview feature that allows testing an expression against a pattern using switch.

Question 11

An application built with Java 17 uses a third-party library that internally uses `sun.misc.Unsafe`. The application runs without errors on Java 8 but throws an `IllegalAccessError` on Java 17. What is the most likely reason?

Accepted Answer

Strong encapsulation of JDK internals is enforced by default.. In Java 17, strong encapsulation of JDK internals is enforced by default, meaning that code cannot access internal APIs like `sun.misc.Unsafe` via reflection or direct use unless explicitly opened. The `IllegalAccessError` occurs because the third-party library attempts to use `sun.misc.Unsafe`, which is a JDK internal API that is no longer accessible by default. This change was introduced as part of JEP 403 (Strongly Encapsulate JDK Internals) and finalized in Java 17, whereas Java 8 allowed such access.

Answer

The --illegal-access flag is set to permit.

Answer

The module path does not include the library.

Answer

The library is not in a named module.

Question 12

A Java application packaged as a JAR file with a manifest containing `Main-Class: com.example.Main` is correctly run using `java -jar app.jar`. However, when run with `java -cp app.jar com.example.Main`, it throws a `NoClassDefFoundError` for a class `com.example.helper.Util`. What is the most likely cause?

Accepted Answer

The JAR's manifest Class-Path entry is not being honored when using -cp.. When using `java -jar`, the JVM reads the manifest's `Class-Path` entry to locate dependencies. However, when using `-cp` (or `-classpath`), the manifest's `Class-Path` is ignored; the classpath is determined solely by the `-cp` argument. Since `com.example.helper.Util` is not on the explicit classpath, a `NoClassDefFoundError` occurs. This is a fundamental difference in how the JVM resolves classpaths between the two launch modes.

Answer

The Util class is missing from the JAR.

Answer

The -jar option automatically adds the JAR's dependencies to the classpath.

Answer

The main class name is misspelled.

Question 13

A developer wants to include a module in a custom runtime image using jlink. The module's `module-info.java` does not explicitly export any packages. When running the application from the custom image, a ClassNotFoundException is thrown for a class from that module. What is the most likely cause?

Accepted Answer

The module's packages are not exported, making them invisible to other modules.. If a module's `module-info.java` does not explicitly export any packages, those packages are not accessible to other modules at runtime. Even if the module is included in the custom runtime image via jlink, the `ClassNotFoundException` occurs because the class is not exported, making it invisible to other modules. The `jlink` tool includes the module's classes in the image, but without an `exports` directive, the packages remain encapsulated.

Answer

The application does not require the module.

Answer

The module uses an automatic module that is not present.

Answer

The module was not included in the jlink command.

Question 14

Which THREE are valid Java commands for launching a modular application?

Accepted Answer

java -p mods -m com.app. Option A is correct because `java -p mods -m com.app` uses the short forms of `--module-path` (`-p`) and `--module` (`-m`) to launch the module `com.app` from the `mods` directory, which is valid when the main class is declared in the module descriptor. Option B is correct because `java --class-path classes --module-path mods --module com.app` explicitly sets both the class path and module path and launches the named module `com.app`, a fully valid long-form invocation. Option D is correct because `java --module-path mods --module com.app/com.app.Main` specifies the module and its main class directly, which is the standard way to launch a modular application when you want to name the entry point explicitly. Option C is incorrect because it places `classes` on the module path via `-p classes` while naming module `com.app`, which would only work if `classes` actually contained an exploded module named `com.app`; as written it is not a valid general launch command for the scenario. Option E is incorrect because `--add-modules com.app` is used to add modules to the root set for resolution, not as a substitute for specifying the main module to launch, and combining it with `-m com.app` in this way does not form a valid launch command.

Answer

java -p classes -m com.app

Answer

java -p mods --add-modules com.app -m com.app

Question 15

Which TWO are characteristics of a multi-release JAR (MR-JAR)?

Accepted Answer

The root of the JAR contains classes for the oldest supported version.. In a multi-release JAR (MR-JAR), the root of the JAR contains the classes compiled for the oldest supported Java version. This ensures backward compatibility: when the JAR is run on an older JVM that does not understand the META-INF/versions directory, it will use the classes from the root. The JVM automatically selects the appropriate versioned class from the META-INF/versions/<version>/ directory based on the major version of the running Java runtime.

Answer

The version directory must be named with the full version string like "9.0.4".

Answer

It can only contain a single version of each class.

Answer

It is created using the jlink tool.