What is Java practice questions

An application is designed with private fields and public getter/setter methods. Which OOP principle does this exemplify?

Trap 1: Polymorphism

Polymorphism allows one interface to be used for different data types.

Trap 2: Inheritance

Inheritance is about deriving classes from a parent.

Trap 3: Abstraction

Abstraction hides implementation details, but encapsulation is about protecting data.

A
Polymorphism
Why wrong: Polymorphism allows one interface to be used for different data types.
B
Inheritance
Why wrong: Inheritance is about deriving classes from a parent.
C
Encapsulation
Encapsulation bundles data and methods within a class, restricting direct access to the private fields and exposing controlled access through public getter and setter methods. This satisfies the constraint of hiding internal state while providing a defined interface for interaction, preventing external code from corrupting the object’s data integrity.
D
Abstraction
Why wrong: Abstraction hides implementation details, but encapsulation is about protecting data.

Question 2easymultiple choice

Which component of the Java platform is responsible for executing compiled bytecode?

Trap 1: JRE

JRE contains the JVM but is not the component that directly executes bytecode.

Trap 2: JDK

JDK is for development, not execution.

Trap 3: Java Compiler

The compiler converts source code to bytecode.

A
JRE
Why wrong: JRE contains the JVM but is not the component that directly executes bytecode.
B
JVM
The Java Virtual Machine executes bytecode.
C
JDK
Why wrong: JDK is for development, not execution.
D
Java Compiler
Why wrong: The compiler converts source code to bytecode.

Question 3mediummultiple choice

A developer is writing a Java application that processes a large number of transactions. The application must ensure that each transaction is committed only if all steps complete successfully, otherwise the entire transaction should be rolled back. Which Java concept should the developer use to implement this requirement?

Trap 1: Inheritance

Inheritance is for code reuse, not transaction management.

Trap 2: Multithreading

Multithreading handles concurrent execution, not transactional integrity.

Trap 3: Encapsulation

Encapsulation hides data, not manage transactions.

A
Exception handling
Exception handling can catch failures and trigger rollback.
B
Inheritance
Why wrong: Inheritance is for code reuse, not transaction management.
C
Multithreading
Why wrong: Multithreading handles concurrent execution, not transactional integrity.
D
Encapsulation
Why wrong: Encapsulation hides data, not manage transactions.

Question 4easymultiple choice

A team is designing a Java application that needs to run on different operating systems without modification. Which Java feature makes this possible?

Trap 1: Just-in-time compilation

JIT improves performance, not portability.

Trap 2: Garbage collection

Garbage collection automates memory management, not portability.

Trap 3: The Java compiler

The compiler generates bytecode, but portability requires JVM.

A
The Java Virtual Machine
JVM interprets bytecode on any platform, providing portability.
B
Just-in-time compilation
Why wrong: JIT improves performance, not portability.
C
Garbage collection
Why wrong: Garbage collection automates memory management, not portability.
D
The Java compiler
Why wrong: The compiler generates bytecode, but portability requires JVM.

Question 5hardmulti select

Which TWO statements correctly describe the Java language? (Choose two.)

Trap 1: Java supports multiple inheritance of implementation.

Java supports multiple inheritance of type via interfaces, not implementation.

Trap 2: Java supports operator overloading.

Java does not support user-defined operator overloading.

Trap 3: Java supports multiple inheritance of classes.

Java does not allow multiple inheritance of classes to avoid diamond problem.

A
Java supports multiple inheritance of implementation.
Why wrong: Java supports multiple inheritance of type via interfaces, not implementation.
B
Java supports operator overloading.
Why wrong: Java does not support user-defined operator overloading.
C
Java supports object-oriented programming.
Java is primarily object-oriented.
D
Java supports multiple inheritance of classes.
Why wrong: Java does not allow multiple inheritance of classes to avoid diamond problem.
E
Java is a statically typed language.
Variables must be declared with a type before use.

Question 6mediummultiple choice

A developer runs the command shown in the exhibit. The developer wants to ensure the application uses the latest available language features. Which action should the developer take?

Exhibit

Refer to the exhibit.
```
$ java -version
java version "1.8.0_201"
Java(TM) SE Runtime Environment (build 1.8.0_201-b09)
Java HotSpot(TM) 64-Bit Server VM (build 25.201-b09, mixed mode)
```

Trap 1: Enable lambda expressions by setting the -enable-lambdas flag.

No such flag; lambdas are supported in Java 8.

Trap 2: Use the -source and -target flags to compile for a newer version.

These flags only affect compilation; the runtime still uses the old version.

Trap 3: Upgrade the JVM to the latest version.

The JVM version matches the JDK; the JDK itself must be upgraded.

A
Download and install a newer version of the JDK.
A newer JDK includes both compiler and runtime with latest features.
B
Enable lambda expressions by setting the -enable-lambdas flag.
Why wrong: No such flag; lambdas are supported in Java 8.
C
Use the -source and -target flags to compile for a newer version.
Why wrong: These flags only affect compilation; the runtime still uses the old version.
D
Upgrade the JVM to the latest version.
Why wrong: The JVM version matches the JDK; the JDK itself must be upgraded.

Question 7hardmultiple choice

A company is developing a Java-based inventory management system. The system runs on a single server and processes up to 1000 concurrent requests. The development team has implemented the code using multiple threads to handle requests. Recently, the system has been experiencing intermittent data corruption in the inventory counts. After reviewing the code, the team suspects that the issue is related to thread safety. The team is considering the following solutions: (A) Use the 'synchronized' keyword on all methods that update inventory counts. (B) Use 'volatile' keyword on the inventory count variables. (C) Use 'AtomicInteger' for inventory counts. (D) Increase the number of threads to handle requests faster. Which solution should the team implement to fix the data corruption issue with minimal performance impact?

Trap 1: Increase the number of threads to handle requests faster.

More threads can increase contention and does not fix data corruption.

Trap 2: Use 'volatile' keyword on the inventory count variables.

Volatile does not guarantee atomicity for compound operations like increment.

Trap 3: Use the 'synchronized' keyword on all methods that update inventory…

Synchronization can cause contention and performance issues.

A
Use 'AtomicInteger' for inventory counts.
AtomicInteger provides lock-free, thread-safe operations with good performance.
B
Increase the number of threads to handle requests faster.
Why wrong: More threads can increase contention and does not fix data corruption.
C
Use 'volatile' keyword on the inventory count variables.
Why wrong: Volatile does not guarantee atomicity for compound operations like increment.
D
Use the 'synchronized' keyword on all methods that update inventory counts.
Why wrong: Synchronization can cause contention and performance issues.

Question 8mediumdrag order

Arrange the steps to compile and run a Java program from the command line in the correct order.

Drag steps to the numbered slots on the right, or tap a step then tap a slot.

Steps

Order

1Step 1

2Step 2

3Step 3

4Step 4

5Step 5

Trap 1: Write code, Open terminal, Compile with javac, Navigate to file…

This is incorrect because you must navigate to the directory containing the Java file before compiling; otherwise, javac will not find the file.

Trap 2: Open terminal, Write code, Navigate to file directory, Compile with…

This is incorrect because writing code should be done before opening the terminal; typically you write and save the Java file in an editor, then use the terminal to compile and run.

Trap 3: Write code, Open terminal, Navigate to file directory, Run with…

This is incorrect because you must compile the Java file before running it; running without compilation will result in a 'could not find or load main class' error.

A
Write code, Open terminal, Navigate to file directory, Compile with javac, Run with java
This is the correct order because you first create the Java source file, then open a terminal, navigate to the directory containing the file, compile it using javac to generate a .class file, and finally run the compiled program using java.
B
Write code, Open terminal, Compile with javac, Navigate to file directory, Run with java
Why wrong: This is incorrect because you must navigate to the directory containing the Java file before compiling; otherwise, javac will not find the file.
C
Open terminal, Write code, Navigate to file directory, Compile with javac, Run with java
Why wrong: This is incorrect because writing code should be done before opening the terminal; typically you write and save the Java file in an editor, then use the terminal to compile and run.
D
Write code, Open terminal, Navigate to file directory, Run with java, Compile with javac
Why wrong: This is incorrect because you must compile the Java file before running it; running without compilation will result in a 'could not find or load main class' error.

Question 9mediumdrag order

Arrange the steps to overload a method in Java in the correct order.

Drag steps to the numbered slots on the right, or tap a step then tap a slot.

Steps

Order

1Step 1

2Step 2

3Step 3

4Step 4

5Step 5

Trap 1: Define a method, then ensure the method signatures are unique, then…

This is incorrect because you cannot ensure unique signatures before defining the second method; uniqueness is checked after both methods exist.

Trap 2: Define another method with the same name but different parameters,…

This is incorrect because the order is reversed; you need an initial method to overload, so the first method must be defined before the second.

Trap 3: Call the method with arguments, then define a method, then define…

This is incorrect because you cannot call a method before it is defined; methods must exist before they can be invoked.

A
Define a method, then define another method with the same name but different parameters, then ensure the method signatures are unique, then call the method with arguments that match one of the signatures.
This is the correct order because you must have at least one method defined before you can overload it, then you create a second method with the same name but a different parameter list, verify that the signatures are indeed different, and finally call the method with appropriate arguments.
B
Define a method, then ensure the method signatures are unique, then define another method with the same name but different parameters, then call the method with arguments.
Why wrong: This is incorrect because you cannot ensure unique signatures before defining the second method; uniqueness is checked after both methods exist.
C
Define another method with the same name but different parameters, then define a method, then ensure unique signatures, then call the method.
Why wrong: This is incorrect because the order is reversed; you need an initial method to overload, so the first method must be defined before the second.
D
Call the method with arguments, then define a method, then define another method with the same name but different parameters, then ensure unique signatures.
Why wrong: This is incorrect because you cannot call a method before it is defined; methods must exist before they can be invoked.

Question 10mediummatching

Match each Java term to its correct definition.

Drag a concept onto its matching description — or click a concept then click the description.

Concepts

Matches

Java Virtual Machine that executes bytecode

Runtime environment including JVM and core libraries

Development kit including JRE and tools like javac

Just-In-Time compiler that optimizes bytecode at runtime

Garbage Collector that automatically manages memory

Trap 1: JDK: Runtime environment that includes the JVM and core libraries…

This describes the JRE, not the JDK. The JDK is a development kit, not just a runtime.

Trap 2: JVM: Software development kit that includes tools for compiling,…

This describes the JDK, not the JVM. The JVM is an execution engine, not a development kit.

A
JDK: Software development kit that includes tools for compiling, debugging, and running Java programs
JDK (Java Development Kit) provides compilers, debuggers, and other tools needed to develop Java applications.
B
JRE: Runtime environment that includes the JVM and core libraries required to run Java programs
JRE (Java Runtime Environment) provides the JVM and class libraries to execute compiled Java programs.
C
JVM: Platform-independent execution engine that interprets Java bytecode into machine code
JVM (Java Virtual Machine) translates bytecode into native instructions for the underlying OS and hardware.
D
Java bytecode: Intermediate representation of Java source code that runs on the JVM
Java bytecode is the compiled output from Java source code, executed by the JVM.
E
JDK: Runtime environment that includes the JVM and core libraries required to run Java programs
Why wrong: This describes the JRE, not the JDK. The JDK is a development kit, not just a runtime.
F
JVM: Software development kit that includes tools for compiling, debugging, and running Java programs
Why wrong: This describes the JDK, not the JVM. The JVM is an execution engine, not a development kit.

Question 11mediummatching

Match each OOP concept to its Java implementation.

Drag a concept onto its matching description — or click a concept then click the description.

Concepts

Matches

Using private fields with public getters/setters

Using extends keyword to derive a class

Method overriding and overloading

Using abstract classes and interfaces

Using fields that reference other objects

Trap 1: Polymorphism: abstract class and interface

Incorrect — abstract classes and interfaces are used for abstraction, not polymorphism.

Trap 2: Abstraction: Method overriding

Incorrect — method overriding is a form of polymorphism, not abstraction.

Trap 3: Inheritance: Use of private fields

Incorrect — private fields are used for encapsulation, not inheritance.

A
Encapsulation: Use of private fields with public getter and setter methods
Encapsulation hides internal state and requires access through methods.
B
Inheritance: extends keyword
Inheritance in Java is implemented using the extends keyword.
C
Polymorphism: abstract class and interface
Why wrong: Incorrect — abstract classes and interfaces are used for abstraction, not polymorphism.
D
Abstraction: Method overriding
Why wrong: Incorrect — method overriding is a form of polymorphism, not abstraction.
E
Polymorphism: Method overriding with dynamic dispatch
Polymorphism allows a subclass to provide a specific implementation of a method.
F
Inheritance: Use of private fields
Why wrong: Incorrect — private fields are used for encapsulation, not inheritance.

Question 12easymultiple choice

A developer says Java is platform-independent because of the JVM. Which statement best explains this?

Trap 1: Java source code is compiled directly into native machine code for…

Java compiles to bytecode, not native code.

Trap 2: The JVM is written in platform-independent code, allowing it to run…

The JVM is platform-specific, but bytecode is not.

Trap 3: Java uses an interpreter only, so the source code is interpreted…

Java uses both compilation (to bytecode) and interpretation/JIT.

A
Java source code is compiled directly into native machine code for each platform.
Why wrong: Java compiles to bytecode, not native code.
B
Java source code is compiled into bytecode, which runs on the Java Virtual Machine (JVM).
Bytecode is platform-independent and executed by the JVM.
C
The JVM is written in platform-independent code, allowing it to run anywhere.
Why wrong: The JVM is platform-specific, but bytecode is not.
D
Java uses an interpreter only, so the source code is interpreted directly on any platform.
Why wrong: Java uses both compilation (to bytecode) and interpretation/JIT.

Question 13mediummultiple choice

A company is developing a security-sensitive banking application. Which Java feature most directly enhances security?

Trap 1: Automatic garbage collection

Garbage collection prevents memory leaks, but is not a primary security feature.

Trap 2: Platform independence via bytecode

Platform independence is about portability, not security.

Trap 3: Built-in multithreading support

Multithreading is for concurrent programming, not direct security.

A
Automatic garbage collection
Why wrong: Garbage collection prevents memory leaks, but is not a primary security feature.
B
Platform independence via bytecode
Why wrong: Platform independence is about portability, not security.
C
Built-in multithreading support
Why wrong: Multithreading is for concurrent programming, not direct security.
D
Bytecode verification
Bytecode verification checks code for security violations before execution.

Question 14hardmultiple choice

A team deploys a Java application and observes frequent Full GC pauses. Which garbage collector is designed to minimize pause times?

Trap 1: Concurrent Mark Sweep (CMS) (-XX:+UseConcMarkSweepGC)

CMS is deprecated and can lead to fragmentation and longer pauses.

Trap 2: Serial GC (-XX:+UseSerialGC)

Serial GC uses a single thread and has long stop-the-world pauses.

Trap 3: Parallel GC (-XX:+UseParallelGC)

Parallel GC prioritizes throughput over pause times.

A
Garbage-First (G1GC) (-XX:+UseG1GC)
G1GC aims to limit pause times and reduce Full GC frequency.
B
Concurrent Mark Sweep (CMS) (-XX:+UseConcMarkSweepGC)
Why wrong: CMS is deprecated and can lead to fragmentation and longer pauses.
C
Serial GC (-XX:+UseSerialGC)
Why wrong: Serial GC uses a single thread and has long stop-the-world pauses.
D
Parallel GC (-XX:+UseParallelGC)
Why wrong: Parallel GC prioritizes throughput over pause times.

Question 15easymultiple choice

What is the primary role of the Java Development Kit (JDK) compared to the JRE?

Trap 1: JDK provides only a debugger and profiler.

JDK includes many tools, not just debugger/profiler.

Trap 2: JRE includes the JDK and additional libraries.

JDK includes JRE, not the opposite.

Trap 3: JDK is required to run Java applications, whereas JRE is not.

JRE is sufficient to run applications; JDK is for development.

A
JDK provides only a debugger and profiler.
Why wrong: JDK includes many tools, not just debugger/profiler.
B
JRE includes the JDK and additional libraries.
Why wrong: JDK includes JRE, not the opposite.
C
JDK is required to run Java applications, whereas JRE is not.
Why wrong: JRE is sufficient to run applications; JDK is for development.
D
JDK includes compilers and tools for developing Java applications.
JDK contains javac, debugger, etc., which JRE lacks.

Question 16hardmultiple choice

In the Java memory model, where are primitive local variables declared inside a method stored?

Trap 1: Heap

Heap stores objects and arrays, not local primitives.

Trap 2: Native method area

Native area is for native method stacks.

Trap 3: Method area

Method area stores class structures, not local variables.

A
Heap
Why wrong: Heap stores objects and arrays, not local primitives.
B
Native method area
Why wrong: Native area is for native method stacks.
C
Stack
Local variables, including primitives, live on the stack.
D
Method area
Why wrong: Method area stores class structures, not local variables.

Question 17easymultiple choice

What is the primary purpose of Java bytecode?

Trap 1: To be compiled into native code once and reused

Bytecode may be JIT-compiled, but it's interpreted initially.

Trap 2: To be human-readable source code

Source code is human-readable; bytecode is binary.

Trap 3: To be directly executed by the operating system

Bytecode requires JVM; OS cannot execute it directly.

A
To be executed by the Java Virtual Machine on any platform
Bytecode is platform-independent and executed by JVM.
B
To be compiled into native code once and reused
Why wrong: Bytecode may be JIT-compiled, but it's interpreted initially.
C
To be human-readable source code
Why wrong: Source code is human-readable; bytecode is binary.
D
To be directly executed by the operating system
Why wrong: Bytecode requires JVM; OS cannot execute it directly.

Question 18mediummultiple choice

During execution, the JVM uses Just-In-Time (JIT) compilation. What is its primary benefit?

Trap 1: Translates bytecode into an intermediate language for…

JIT compiles to native code, not another intermediate language.

Trap 2: Converts Java source code directly into bytecode.

javac does source to bytecode compilation.

Trap 3: Enhances security by verifying bytecode integrity.

Bytecode verification is a separate step, not JIT.

A
Translates bytecode into an intermediate language for interpretation.
Why wrong: JIT compiles to native code, not another intermediate language.
B
Improves execution speed by compiling frequently used bytecode to native code.
JIT identifies hot spots and compiles them for faster execution.
C
Converts Java source code directly into bytecode.
Why wrong: javac does source to bytecode compilation.
D
Enhances security by verifying bytecode integrity.
Why wrong: Bytecode verification is a separate step, not JIT.

Question 19hardmultiple choice

A company wants to run existing Java SE application code on an embedded device with limited resources. Which Java edition is designed for such environments?

Trap 1: Java Card

Java Card is for ultra-small devices like smart cards, not general embedded.

Trap 2: Java FX

Java FX is a client platform for rich internet applications, not an edition.

Trap 3: Java EE (Enterprise Edition)

Java EE is for large-scale server applications.

A
Java Card
Why wrong: Java Card is for ultra-small devices like smart cards, not general embedded.
B
Java FX
Why wrong: Java FX is a client platform for rich internet applications, not an edition.
C
Java EE (Enterprise Edition)
Why wrong: Java EE is for large-scale server applications.
D
Java ME (Micro Edition)
Java ME is tailored for embedded and mobile devices.

Question 20easymulti select

Which TWO statements are true about the Java programming language?

Trap 1: It is a purely procedural language.

Java is primarily object-oriented.

Trap 2: It supports direct pointer manipulation for memory access.

Java does not have pointers; it uses references.

Trap 3: It allows multiple inheritance of classes.

Java only allows single inheritance of classes; multiple inheritance is via interfaces.

A
It is a purely procedural language.
Why wrong: Java is primarily object-oriented.
B
It supports direct pointer manipulation for memory access.
Why wrong: Java does not have pointers; it uses references.
C
It is a strongly-typed language.
All variables must have a declared type.
D
It allows multiple inheritance of classes.
Why wrong: Java only allows single inheritance of classes; multiple inheritance is via interfaces.
E
It provides automatic memory management through garbage collection.
GC automatically reclaims memory from unreferenced objects.