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

Question 1

You are a software architect at a financial firm. Your team is developing a modular Java 17 application that comprises several modules: 'com.bank.core' (provides core banking services), 'com.bank.web' (REST API), and 'com.bank.persistence' (database access). The application uses the 'java.sql' module for JDBC and 'java.logging' for logging. The team uses Maven for dependency management. The application has an external dependency on the 'com.fasterxml.jackson.databind' library (Jackson) for JSON processing, which is provided as a non-modular jar. The Jackson jar is placed on the module path. The application modules are all named modules with module-info files. At runtime, the 'com.bank.web' module requires 'com.bank.core' and 'com.fasterxml.jackson.databind' (the automatic module). The 'com.bank.core' module requires 'java.sql' and 'java.logging'. When the application runs, it throws an 'IllegalAccessError' indicating that the module 'com.bank.core' tries to access a class from 'com.fasterxml.jackson.databind' but the module does not read it. Yet, 'com.bank.web' is the only module that explicitly requires Jackson. What is the most likely cause and the correct resolution?

Choose an answer to begin — your selection is scored in the full session.

Accepted Answer

Add 'requires com.fasterxml.jackson.databind' to the module-info.java of 'com.bank.core' because it uses Jackson classes directly.. The error indicates that 'com.bank.core' directly uses classes from 'com.fasterxml.jackson.databind', but its module-info.java does not include a 'requires com.fasterxml.jackson.databind' directive. In the Java module system, a module can only access types from another module if it explicitly reads that module. Since 'com.bank.core' needs Jackson classes at runtime, it must declare the dependency itself, even if another module ('com.bank.web') also requires it.

Answer

Convert all application modules to unnamed modules by removing module-info files.

Answer

Place the Jackson jar on the classpath instead of the module path.

Answer

Use jlink to create a custom runtime image including all modules and the Jackson jar.

Question 2

A team is migrating a large legacy application from Java 8 to Java 17. The application consists of multiple JAR files that are placed on the classpath. Some of these JAR files have been updated to include module-info.class files, making them named modules. After migration, the application throws `IllegalAccessError` for several deep reflection calls that used to work in Java 8. The team has added `--add-opens` JVM flags to open the required packages, but the error persists. The application also uses a third-party library that is not modularized and is placed on the classpath. The team notices that the `--add-opens` flags are being ignored for packages in the modularized JARs. What is the most likely reason?

Accepted Answer

The modularized JARs are being loaded from the classpath, so they become unnamed modules, and `--add-opens` does not apply to unnamed modules.. When a JAR file containing a module-info.class is placed on the classpath instead of the module path, it is treated as an unnamed module. The `--add-opens` JVM flag only applies to named modules (those on the module path) and has no effect on unnamed modules. Since the modularized JARs are loaded from the classpath, they become unnamed modules, and the `--add-opens` flags are ignored, causing the `IllegalAccessError` to persist.

Answer

The `--add-opens` flags are being overridden by other JVM flags.

Answer

The application does not have a module-info.java file for its own code.

Answer

The classpath is deprecated and ignored in Java 17, so all JARs are treated as modules.

Question 3

A developer needs to compile and execute a Java application on a server. Which of the following environments is sufficient to perform both tasks?

Accepted Answer

JDK only. The JDK (Java Development Kit) includes both the javac compiler for compiling source code into bytecode and the java runtime launcher (JRE) for executing that bytecode. The JRE alone provides only the runtime environment (JVM, core libraries) and cannot compile Java source files. Therefore, the JDK is sufficient for both compiling and executing, while the JRE is not.

Answer

Both JDK and JRE

Answer

Neither JDK nor JRE

Answer

JRE only

Question 4

Which statement is true about the result of executing the jlink command shown in the exhibit?

Accepted Answer

It creates a runtime image containing the com.example.app module and its resolved dependencies.. The jlink command creates a custom runtime image that includes the specified module (com.example.app) and all of its resolved dependencies. It does not compile the module; compilation is done separately with javac. The resulting image is a directory structure with the JRE and module files, not a JAR.

Answer

It compiles the com.example.app module before creating the image.

Answer

It creates a runtime image that includes only the com.example.app module.

Answer

It creates a JAR file containing the com.example.app module.

Question 5

A developer compiles a set of Java 17 source files into a directory named out and wants to run the main class com.example.Main while ensuring that only the classes in out are used. Which command accomplishes this?

Accepted Answer

java --class-path out com.example.Main. The java launcher uses the class path to find application classes. Specifying --class-path out restricts the search to the out directory, so only the compiled classes there are used. Other forms either misinterpret the argument type (a file path or a directory for -jar) or assume a modular layout that is not present.

Answer

java --module-path out --module com.example.Main

Answer

java -jar out

Answer

java -cp out com/example/Main.class

Question 6

A development team is packaging a Java 17 application as a modular JAR. The module descriptor includes 'requires transitive java.logging;'. A client module that requires the application module wants to use java.util.logging.Logger directly. What is the effect of the 'transitive' modifier in this scenario?

Accepted Answer

The client module automatically reads the java.logging module without declaring 'requires java.logging' itself.. The 'requires transitive' directive establishes an implied readability relationship: any module that reads the application module also reads java.logging. Consequently, the client module can use java.util.logging.Logger without an explicit requires clause. The other options incorrectly limit the scope of transitive or confuse exports with readability.

Answer

The client module must still declare 'requires java.logging' to access Logger, because transitive only affects compilation of the application module.

Answer

The 'transitive' modifier makes java.logging available only to the application module's own packages, not to client modules.

Answer

The client module can access Logger only if it also exports a package that contains a public API using Logger.

Question 7

A Java 17 application is packaged as a modular JAR with a module descriptor that contains `requires transitive com.acme.core;`. A separate module, com.acme.client, declares `requires com.acme.app;`. Which statement is true about the readability of com.acme.core from com.acme.client?

Accepted Answer

com.acme.client can read com.acme.core because the transitive modifier propagates readability to modules that depend on com.acme.app.. The `requires transitive` modifier propagates readability: any module that reads the declaring module also reads the module named in the directive. Since com.acme.client requires com.acme.app, and com.acme.app requires transitive com.acme.core, com.acme.client automatically reads com.acme.core without an additional requires clause.

Answer

The transitive modifier applies only to automatic modules and has no effect on explicit modules.

Answer

com.acme.client can read com.acme.core only if com.acme.core exports the packages that com.acme.client uses.

Answer

com.acme.client cannot read com.acme.core unless it declares its own `requires com.acme.core;` directive.

Question 8

A developer is packaging a Java 17 application as a modular JAR. The module descriptor contains `exports com.acme.api;` but does not contain `opens com.acme.api;`. Another module wants to use reflection to access private fields of a class in com.acme.api at runtime. What is the result?

Accepted Answer

The reflective access to private fields fails with an InaccessibleObjectException unless the package is opened.. Strong encapsulation in the Java Platform Module System means that `exports` only exposes public types and their public members. Reflective access to private fields requires the package to be opened with the `opens` directive. Without it, the runtime throws InaccessibleObjectException, even if the module reads the target module.

Answer

The reflective access fails at compile time because private fields cannot be referenced from another module.

Answer

The reflective access succeeds because exports also allows deep reflection.

Answer

The reflective access succeeds only if the other module declares `requires transitive com.acme.api;`.

Question 9

A developer compiles a Java 17 application into a modular JAR with the module descriptor `module com.acme.inventory { exports com.acme.inventory.api; }`. The JAR also contains the package `com.acme.inventory.internal` with public classes. Another module `com.acme.reporting` declares `requires com.acme.inventory;` and attempts to import `com.acme.inventory.internal.StockLedger`. What is the result?

Accepted Answer

Compilation fails because `com.acme.inventory.internal` is not exported by `com.acme.inventory`.. A named module grants access to its public types only from packages it explicitly exports. Here `com.acme.inventory` exports just the `api` package, so another module cannot compile against types in `internal`. The `requires` directive establishes readability but does not bypass the export gate. The compiler therefore rejects the import, and no runtime behavior is reached.

Answer

Compilation succeeds, but at runtime an `IllegalAccessError` is thrown when `StockLedger` is first used.

Answer

Compilation succeeds because public classes in non-exported packages are still accessible to modules that `requires` the providing module.

Answer

Compilation succeeds only if `com.acme.reporting` adds `requires transitive com.acme.inventory` instead of `requires com.acme.inventory`.

Question 10

A developer compiles a modular application with javac -d out --module-source-path src $(find src -name '*.java'). The source tree contains src/com.example.inventory/module-info.java and several packages. Later, a colleague runs the application with java --module-path out --module com.example.inventory/com.example.inventory.Main. The main class is in package com.example.inventory. Which statement describes what must be true for this launch to succeed?

Accepted Answer

The main class must be specified as module/class, and the module must be observable on the module path at launch time.. Launching a modular application requires the module to be observable on the module path and the entry point to be identified with module/class syntax. The launcher performs resolution, then loads the named class from that resolved module. Exports and opens govern access for other modules, not the launcher's ability to invoke the main class, so they do not determine success in this scenario.

Answer

The module must export com.example.inventory or open it to at least the launching code.

Answer

The compiled output directory must be packaged as a modular JAR before the java command can use it.

Answer

The module must declare requires java.base explicitly, otherwise resolution fails.

Question 11

A Java 17 application is packaged as a modular JAR `app.jar` containing `module-info.class` for `module com.example.app`. A developer runs `java --module-path mods --module com.example.app/com.example.app.Main`. The module path `mods` contains `app.jar`. What must be true for the launch to succeed?

Accepted Answer

The main class `com.example.app.Main` must declare `public static void main(String[] args)` and the module must be resolvable on the module path.. Launching a named module with `java --module-path ... --module module/class` requires the module to be resolvable from the module path and the main class to expose a standard `public static void main(String[])` entry point. Exports are irrelevant for the module's own main class. Additional module resolution flags are not needed because the specified module becomes the root of the module graph.

Answer

`com.example.app` must export the package containing `Main` to all modules.

Answer

The application must be started with `--add-modules ALL-MODULE-PATH` to make `com.example.app` available.

Answer

`app.jar` must be placed on the class path instead of the module path for the `--module` option to work.

Question 12

A developer creates a custom runtime image with `jlink` for a Java 17 application. The application uses the `java.sql` module, which is not part of the `java.base` module. The command used is `jlink --module-path $JAVA_HOME/jmods --add-modules com.example.app --output myimage`. The application fails at runtime with `NoClassDefFoundError: java/sql/DriverManager`. What is the most likely cause?

Accepted Answer

The application module does not declare `requires java.sql`, so the module was not resolved and thus not linked into the image.. `jlink` builds a runtime image from the transitive closure of the specified root modules. If the application module uses `java.sql` but does not declare `requires java.sql`, the module is not part of the resolved graph, so it is excluded from the image. At runtime, loading `DriverManager` fails. Adding the `requires` directive or explicitly adding `java.sql` with `--add-modules` resolves the issue.

Answer

The `jlink` command must include `--bind-services` to include `java.sql` because it provides a service provider.

Answer

The `java.sql` module is not available in the `jmods` directory of a JDK 17 installation and must be added from a separate download.

Answer

The `java.sql` module was not included because `jlink` does not automatically resolve transitive dependencies of the application module.

Question 13

A Java 17 application is packaged as a modular JAR with a module-info.class that declares 'requires transitive java.logging;'. The application is then placed on the module path along with another module that requires the application module. Which two statements are true about the readability of java.logging? (Choose two.)

Accepted Answer

The application module can read java.logging.. The 'requires transitive' directive in a module descriptor has two effects: it makes the dependency readable by the declaring module, and it propagates that readability to any module that requires the declaring module. Therefore, both the application module and its dependents can read java.logging. The other options incorrectly suggest that explicit requires are needed or that readability is restricted.

Answer

Modules that require the application module must also explicitly require java.logging to use its types.

Answer

Only modules that explicitly require java.logging can read it.

Answer

The application module cannot read java.logging because it is not exported.

Question 14

A developer needs to inspect the structure of a modular JAR named app.jar to confirm which modules it requires and which packages it exports. Which command should the developer run to display the module descriptor of app.jar?

Accepted Answer

jar --describe-module --file app.jar. The jar tool includes a describe-module mode that reads module-info.class from an archive and prints its directives. Using --file to name the archive lets the developer inspect requires, exports, opens, uses, and provides without extracting anything. Other tools either expect class files, perform dependency analysis, or require a module name resolved from the module path rather than a direct path to the JAR.

Answer

jdeps --module-path app.jar --list-modules

Answer

java --module-path app.jar --describe-module app

Answer

javap -v app.jar

Question 15

A Java 17 application is deployed as a set of modular JARs. The module com.example.app requires com.example.lib. Which two statements are true about the readability and accessibility between these modules? (Choose two.)

Accepted Answer

If com.example.lib does not export a package, com.example.app cannot access public types in that package.. Readability is granted by the 'requires' directive, but accessibility requires that the providing module exports the relevant package. Therefore, com.example.app can access public types only in packages exported by com.example.lib. Exporting one's own packages is unrelated to reading another module, and requires is not bidirectional.

Answer

com.example.app must also export its own packages to read com.example.lib.

Answer

com.example.app can access all public types in all packages of com.example.lib, regardless of exports.

Answer

The 'requires' directive in com.example.app makes com.example.lib read com.example.app automatically.