LDC: Lower Division Clerk — Role, Skills & Exam Essentials: 18 MCQs with answers

Load Constant

`ldc` expands to **Load Constant**. It is the JVM instruction that fetches a constant from the class's constant pool and pushes it onto the operand stack.

The class's constant pool

`ldc` reads from the **constant pool** of the current class. Local variables are read by the `*load` family (`iload`, `aload`, `fload`), and static fields by `getstatic`.

1 byte

`ldc` carries a **1-byte unsigned index** (0–255), which keeps the bytecode compact. The 2-byte form is `ldc_w`.

`ldc2_w`

`long` and `double` occupy **two operand-stack slots**, so they require `ldc2_w`. Plain `ldc` handles only single-slot values.

Entry 7 in the class's constant pool

The number after `ldc` is the **constant pool index**. Entry 7 in this class's pool holds the string `hello`, which `javap` helpfully prints as a comment.

True

**ldc** is a JVM bytecode instruction that loads a constant from the class's constant pool onto the operand stack, using a 1-byte index.

`ldc_w`

A 1-byte index can only address 0–255, so a 400-entry pool needs the **2-byte index** of `ldc_w`. `ldc2_w` is reserved for `long` and `double`.

It deduplicates literals and allows lazy resolution

The pool **deduplicates** repeated literals — one entry, many `ldc` references — and enables **lazy resolution**, so a class reference is not loaded until an `ldc` actually touches it.

`iload_1` reads a local variable; `ldc 5` pushes a pool constant

The `*load` family reads **local variable slots** in the stack frame, while `ldc` reads the **constant pool**. They share the word "load" but are unrelated mechanisms.

A `Class` literal such as `String.class`

`ldc` handles single-slot constants including `int`, `float`, `String`, `Class`, `MethodType`, `MethodHandle` and `Dynamic`. `long` and `double` need `ldc2_w`, and local variables need `*load`.

`long` takes two stack slots, so it needs `ldc2_w`

The deciding factor is **operand-stack slot count**: `long` and `double` occupy two slots, so the JVM provides `ldc2_w` for them. Both values still live in the constant pool.

`getstatic`

`getstatic` reads a **static field's value**. `ldc` and its variants push constants from the pool, and `bipush` pushes a small integer literal inline.

The string literal `"Hi"` must be pushed from the constant pool

`System.out` is fetched with `getstatic`, but the argument `"Hi"` is a **string literal**, so the compiler emits `ldc` to push it onto the operand stack before `invokevirtual`.

`javap -c` on the class file

`javap -c` disassembles the class and prints each `ldc` with its **pool index and a comment** showing the value, e.g. `ldc #7 // String hello`. That is the fastest way to read stack-based execution.

II and III only

The constant pool is **per-class**, not global, so statement I is wrong. Statements II (lazy resolution) and III (deduplication) are both correct.

Both rely on `ldc` to push a pool entry before resolution

A `Class` literal and the class-name string passed to `Class.forName` are both **constant pool entries**, so `ldc` pushes them before the JVM resolves the class. Neither takes two slots, so `ldc2_w` is not involved.

ldc_w

The correct option is `ldc_w` because it is used for constant pools with more than 255 entries, ensuring that the string literal can be correctly referenced without exceeding the index limit.

The string uses `ldc`, while the double uses `ldc2_w`

The correct option is that the string uses `ldc` because it fits within a single slot, while the double requires `ldc2_w` because it occupies two slots on the operand stack.