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`.
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`.
