Y. Daniel Liang Introduction to Java Programming 12th Edition Test Bank | Java Programming Questions 2026/2027

Y. Daniel Liang Introduction to Java Programming 12th Edition Test Bank |
150+ Object-Oriented Principles Code Snippet Answers 2026/2027
CS 1301: Introduction to Java Programming Prep with Detailed Rationales
*Course Code:* CS 1301

*Course Name:* Introduction to Java Programming

*Topic:* Object-Oriented Principles & Code Snippets

*Academic Year:* 2026/2027

---

📋 STUDY CORE TOPICS OUTLINE
* Topic 1: Java Elementary Syntax, Primitives, Operations, and Memory Allocation

* Topic 2: Selection Statements, Loop Control, and Floating-Point Precision

* Topic 3: Methods, Pass-by-Value Semantics, and Call Stack Execution

* Topic 4: Single and Multidimensional Arrays, System.arraycopy, and Sorting
Algorithms

* Topic 5: Object-Oriented Fundamentals: Classes, Objects, Constructors, and
Garbage Collection

* Topic 6: Encapsulation, Scope, Visibility Modifiers, and Static vs. Instance
Members

* Topic 7: Inheritance, Polymorphism, Dynamic Binding, and Explicit Casting

* Topic 8: Abstract Classes, Interfaces, Generics, and Exceptional Control Flow

---

📚 TEXTBOOK ALIGNMENT INDEX
| Part / Section | Topic Coverage Range | Question Index Range |

| :--- | :--- | :--- |

| Part I: Core Principles | Java Primitives, Operators, Loops, and Control Structures |
Questions 1 – 30 |

| Part II: Intermediate Analysis | Methods, Array Data Structures, and Memory
Stack/Heap | Questions 31 – 60 |

,| Part III: Advanced Syntheses | OOP Core, Constructors, Static Scoping, and
Encapsulation | Questions 61 – 90 |

| Part IV: Diagnostic Integrations | Inheritance, Dynamic Binding, Polymorphism, and
Casting | Questions 91 – 120 |

| Part V: Final Case Overviews | Abstract Classes, Interfaces, Recursion, Exceptions,
and I/O | Questions 121 – 150 |

---

Question 1
In Java, execution begins at the main method entry point. What is the exact execution
outcome of evaluating the expression `System.out.println( + 5.)` within a
standard execution block?

A. 4.5

B. 4

C. 5.0

D. 4.0

*CORRECT ANSWER:* A. 4.5

*RATIONALE:* Integer division occurs when both operands are integers. ``
evaluates to `2` (truncating the decimal). Floating-point division occurs when at least one
operand is a floating-point literal; thus, `5.` evaluates to `2.5`. Adding `2 + 2.5`
performs implicit widening conversion on the integer `2` to `2.0`, yielding `4.5`. Option B
is incorrect because it treats both operations as integer division. Option C incorrectly
rounds up. Option D fails to retain the fractional component of `5.`.

---

Question 2
Consider the primitive numeric type boundaries in Java. Which of the following
assignment statements will cause a compile-time compiler error without an explicit cast?

A. `double d = 100L;`

B. `long x = 2147483648L;`

C. `int y = 3.14;`

D. `float f = 12.5f;`

*CORRECT ANSWER:* C. `int y = 3.14;`

, *RATIONALE:* Floating-point literals are by default of type `double` in Java.
Assigning a `double` (64-bit precision) to an `int` (32-bit integer) represents a narrowing
conversion, which requires an explicit cast like `(int) 3.14`. Options A, B, and D are valid:
`100L` widens implicitly to `double`, `2147483648L` fits into a `long`, and `12.5f` is
explicitly typed as a `float`.

---

Question 3
Analyze the following Java code snippet evaluating short-circuit logical operators:

```java

int x = 1;

boolean b = (x > 1) && (++x > 1);

System.out.println("x = " + x + ", b = " + b);

```

What is the printed output?

A. x = 2, b = true

B. x = 1, b = false

C. x = 2, b = false

D. x = 1, b = true

*CORRECT ANSWER:* B. x = 1, b = false

*RATIONALE:* The conditional AND operator `&&` exhibits short-circuit behavior.
The left operand `(x > 1)` evaluates to `(1 > 1)`, which is `false`. Because the first
operand is `false`, the entire expression cannot be true, so the right-hand operand `(++x
> 1)` is never evaluated. Consequently, `x` remains `1` and `b` is assigned `false`.

---

Question 4
Evaluate the behavior of switch expressions and string comparison introduced in
modern Java runtime environments. Given the following method:

```java

public static int getCode(String status) {

return switch(status) {

, case "ACTIVE" -> 1;

case "PENDING" -> 2;

default -> 0;

};

}

```

If `status` is passed as `null`, what runtime behavior occurs?

A. Returns 0

B. Compiles but throws NullPointerException at runtime

C. Compilation error occurs because null is not handled

D. Returns -1

*CORRECT ANSWER:* B. Compiles but throws NullPointerException at runtime

*RATIONALE:* Passing `null` to a `switch` expression or statement causes a
`NullPointerException` at runtime when the expression is evaluated, unless explicitly
handled via `case null` in newer Java versions. The compiler allows passing String
variables to switch statements, but runtime evaluation fails on null references.

---

Question 5
What is the resulting value of the expression `15 ^ 6` using bitwise XOR operations in
Java?

A. 21

B. 9

C. 10

D. 0

*CORRECT ANSWER:* B. 9

*RATIONALE:* Converting the integer operands to 8-bit binary representation: `15`
is `00001111` and `6` is `00000110`. Performing the bitwise XOR operation (`^`), where
bits result in `1` if and only if one bit is `1` and the other is `0`:

`00001111 ^ 00000110 = 00001001`.