Week 6: Mid Review

Week 1 — Java Basics

Variables · Data Types · Operators · Loops · Methods · Math class

0 / 20

Easy

EasySingle Choice

Which of the following correctly declares an integer variable in Java?

A. integer x = 5; B. int x = 5; C. Int x = 5; D. INTEGER x = 5;

B is correct. In Java, int is the primitive integer type (lowercase). integer, Int, and INTEGER are not valid Java primitive types. Integer (capital I) is the wrapper class, not a primitive type declaration.

EasySingle Choice

What is the output of the following statement?

System.out.println(10 / 3);

A. 3.33 B. 3 C. 4 D. 3.0

B is correct. Both operands are int, so Java performs integer division — the decimal part is truncated. 10 ÷ 3 = 3 remainder 1, so the result is 3 (not 3.33). To get a decimal result, at least one operand must be a double: 10.0 / 3.

EasySingle Choice

Which loop is guaranteed to execute its body at least once?

A. for loop B. while loop C. do-while loop D. Enhanced for loop

C is correct. The do-while loop checks its condition after executing the body, so it always runs at least once. for and while check the condition before entering the body, so they may never execute if the condition is initially false.

EasySingle Choice

What does Math.abs(-7) return?

A. -7 B. 7 C. 0 D. Compilation error

B is correct. Math.abs(x) returns the absolute value — always non-negative. Math.abs(-7) returns 7. It works on int, long, float, and double types.

EasySingle Choice

Which is the correct signature of the Java main method?

A. public void main(String[] args) B. public static void main(String[] args) C. static void main(String args) D. public static int main(String[] args)

B is correct. The entry point must be public static void main(String[] args). It must be public (JVM can access), static (called without an object), void (returns nothing), and accept a String[] parameter.

Intermediate

IntermediateSingle Choice

What is the output of the following?

System.out.println((int) 3.9);

A. 4 B. 3 C. 3.9 D. Compilation error

B is correct. Explicit casting from double to int truncates (drops the decimal part) — it does NOT round. So (int) 3.9 → 3, not 4. Contrast: Math.round(3.9) would give 4.

IntermediateSingle Choice

Which operator has the HIGHEST precedence among these?

A. + (addition) B. * (multiplication) C. ! (logical NOT) D. == (equality)

C is correct. Operator precedence (high → low): ! → * / % → + - → < <= > >= → == != → && → || → =. The unary logical NOT (!) has higher precedence than any arithmetic or comparison operator listed here.

IntermediateSingle Choice

What is printed?

int x = 5; System.out.println(x++ + " " + ++x);

A. 5 7 B. 6 7 C. 5 6 D. 6 6

A is correct. x++ (post-increment) uses x's current value 5 in the expression, then increments x to 6. Next, ++x (pre-increment) increments x from 6 to 7 first, then uses 7. Output: "5 7".

IntermediateMulti-Select

Which of the following are valid Math class methods in Java?

Select ALL that apply

A. Math.pow(2, 3) B. Math.random() C. Math.abs(-5) D. Math.square(4) E. Math.ceil(3.2)

A, B, C, E are correct. Math.square() does NOT exist in Java — use Math.pow(x, 2) instead. Valid methods: pow, sqrt, abs, max, min, random, ceil, floor, round, log, sin, cos. All are static.

IntermediateSingle Choice

What is printed by this code?

for (int i = 0; i < 5; i++) { if (i == 3) break; System.out.print(i + " "); }

A. 0 1 2 B. 0 1 2 3 C. 0 1 2 3 4 D. 1 2 3

A is correct. The loop prints 0, 1, 2 normally. When i == 3, break immediately exits the loop before printing. So only 0 1 2 is printed.

IntermediateSingle Choice

Which of the following CANNOT be used alone to distinguish two overloaded methods?

A. Different number of parameters B. Different parameter types C. Different return type only D. Different parameter order (with different types)

C is correct. Method overloading is determined by the method signature (name + parameter list). The return type is NOT part of the signature, so two methods with the same name and same parameters but different return types cause a compilation error — they cannot be distinguished by the compiler.

IntermediateMulti-Select

Which of the following are primitive data types in Java?

Select ALL that apply

A. int B. String C. double D. boolean E. char F. Integer

A, C, D, E are correct. Java has 8 primitives: byte, short, int, long, float, double, boolean, char. String is a class (reference type). Integer is the wrapper class for int — also a reference type, not primitive.

Hard

HardSingle Choice

What is the output of this if-else chain?

int x = 10; if (x > 5) { System.out.print("A"); } else if (x > 8) { System.out.print("B"); } else { System.out.print("C"); }

A. A B. AB C. B D. C

A is correct. The first condition x > 5 (10 > 5) is true, so "A" is printed and the entire if-else chain exits. The else if (x > 8) branch is never evaluated — in a chain, once a branch is taken, all others are skipped.

HardMulti-Select

Which statements about widening type conversion in Java are TRUE?

Select ALL that apply

A. It happens automatically (implicit casting) B. It can lose significant data (precision loss) C. A byte can be widened to int automatically D. A double can be widened to float E. It never requires an explicit cast operator

A, C, E are correct. Widening goes from smaller → larger type (byte→short→int→long→float→double) and is automatic. B is wrong: widening generally preserves value (though int/long → float/double can lose precision for very large integers, the concept is about no data loss in normal cases). D is wrong: double → float is narrowing (double is larger), not widening.

HardSingle Choice

What does this code print?

int result = 0; for (int i = 1; i <= 5; i++) { if (i % 2 == 0) continue; result += i; } System.out.println(result);

A. 9 B. 15 C. 6 D. 3

A is correct. continue skips even numbers. Only odd values are added: 1 + 3 + 5 = 9. Trace: i=1 (odd, add→1), i=2 (even, skip), i=3 (odd, add→4), i=4 (even, skip), i=5 (odd, add→9).

HardSingle Choice

Given the method: public static double compute(int a, double b)
Which call is INVALID?

A. compute(3, 4.5) B. compute(3, 4) C. compute(3.0, 4.5) D. compute(3, (double)4)

C is correct (invalid call). The first parameter requires an int. Passing 3.0 (a double) would require narrowing conversion (double→int), which is not done implicitly. B is valid because 4 (int) is widened to double for the second parameter.

HardMulti-Select

Which statements about Java's switch statement are TRUE?

Select ALL that apply

A. A missing break causes fall-through to the next case B. switch can operate on String values (Java 7+) C. switch can operate on double values D. The default clause is mandatory E. break exits the entire switch block

A, B, E are correct. C is wrong: switch supports byte, short, int, char, String, and enums — NOT float or double. D is wrong: default is optional. Fall-through (A) is a common pitfall — always add break unless intentional.

HardSingle Choice

What is the output?

int x = 15; String r = (x % 2 == 0) ? "even" : (x % 3 == 0) ? "div3" : "other"; System.out.println(r);

A. even B. div3 C. other D. Compilation error

B is correct. 15 % 2 = 1 (not 0) → not even. Then: 15 % 3 = 0 → "div3". Nested ternary evaluates left to right. Since 15 is odd but divisible by 3, result = "div3".

HardMulti-Select

Which statements about method parameters and overloading in Java are TRUE?

Select ALL that apply

A. Primitive parameters are passed by value (copy) B. Changes to a primitive parameter inside a method are visible to the caller C. Object references are passed by value (copy of the reference) D. A method can return multiple values directly E. Overloaded methods must differ in their parameter list

A, C, E are correct. B is wrong: primitive changes inside a method do NOT affect the caller (copy was passed). D is wrong: Java returns only one value; use arrays or objects for multiple values. C is correct but subtle: the reference itself is a copy — you can modify the object's fields but can't make the caller's variable point to a different object.

HardSingle Choice

What does this recursive method print when called as System.out.println(mystery(4))?

public static int mystery(int n) { if (n <= 1) return 1; return n + mystery(n - 1); }

A. 4 B. 10 C. 24 D. Infinite recursion

B is correct. This computes the sum 1+2+...+n. Trace: mystery(4) = 4 + mystery(3) = 4 + 3 + mystery(2) = 4+3+2+mystery(1) = 4+3+2+1 = 10. Base case: mystery(1) = 1.

Week 2 — Arrays

1D Arrays · 2D Arrays · Copying · Passing to Methods · java.util.Arrays

0 / 20

Easy

EasySingle Choice

What is the index of the last element in an array of size 10?

A. 10 B. 9 C. 0 D. 11

B is correct. Java arrays are 0-indexed. An array of size 10 has valid indices 0 through 9. Accessing index 10 throws ArrayIndexOutOfBoundsException. Always use arr.length - 1 to get the last index safely.

EasySingle Choice

What is the default value of each element when you create int[] arr = new int[5]?

A. null B. -1 C. 0 D. undefined garbage value

C is correct. Java initializes array elements to default values: int/long/short/byte → 0, double/float → 0.0, boolean → false, char → '\u0000', object references → null. Unlike C/C++, Java never has garbage values.

EasySingle Choice

Which correctly declares and creates an integer array of size 5?

A. int arr = new int[5]; B. int[] arr = new int[5]; C. array int arr[5]; D. int arr[5];

B is correct. The preferred Java syntax places [] after the type: int[] arr = new int[5];. While int arr[] = new int[5]; is also valid (C-style), options A (missing []), C (invalid keyword), and D (C-style without new) are wrong.

EasySingle Choice

How do you get the number of elements in an array arr?

A. arr.size() B. arr.length() C. arr.length D. arr.count

C is correct. Arrays have a length field (not a method — no parentheses). arr.size() is for ArrayList, not arrays. arr.length() would cause a compilation error since length is not a method on arrays.

EasySingle Choice

What does the enhanced for-loop for (int x : arr) do?

A. Iterates with index access, allows element modification B. Iterates through elements without providing the index C. Only works on 2D arrays D. Iterates in reverse order

B is correct. The enhanced for-loop provides each element value but no index. Modifying x (a primitive copy) does NOT change the original array. Use a regular for loop when you need the index or want to modify elements.

Intermediate

IntermediateSingle Choice

What is the output?

int[] arr = {5, 3, 8, 1, 9}; System.out.println(arr[2]);

A. 3 B. 8 C. 1 D. 5

B is correct. Index 0→5, 1→3, 2→8, 3→1, 4→9. Arrays are 0-indexed, so arr[2] is the third element: 8.

IntermediateMulti-Select

Which of the following create a true independent (deep) copy of a primitive array?

Select ALL that apply

A. int[] b = a; B. System.arraycopy(a, 0, b, 0, a.length); C. int[] b = Arrays.copyOf(a, a.length); D. Manual element-by-element loop copy E. int[] b = a.clone();

B, C, D, E are correct. A (int[] b = a) is only a reference copy — both variables point to the same array. Changing one changes the other. Options B, C, D, E all create a new, independent array with copied values.

IntermediateSingle Choice

What exception is thrown when you access arr[-1] or arr[arr.length]?

A. NullPointerException B. ArrayIndexOutOfBoundsException C. IllegalArgumentException D. IndexOutOfRangeException

B is correct. Accessing any index outside [0, length-1] throws ArrayIndexOutOfBoundsException at runtime. NullPointerException occurs when calling methods on a null array reference.

IntermediateSingle Choice

What does Arrays.sort(arr) do to the array?

A. Returns a new sorted array, original unchanged B. Sorts the original array in-place in ascending order C. Sorts in descending order D. Sorts only the first half of the array

B is correct. Arrays.sort(arr) modifies the original array in-place, sorting in ascending order. It returns void. For descending order, you must sort then reverse, or use Arrays.sort(arr, Collections.reverseOrder()) with Integer arrays.

IntermediateMulti-Select

Which statements about 2D arrays in Java are TRUE?

Select ALL that apply

A. matrix.length gives the number of rows B. matrix[0].length gives the number of columns in row 0 C. All rows must have the same length D. Java supports ragged arrays (rows with different lengths) E. Elements are accessed as matrix[row][col]

A, B, D, E are correct. C is false: Java supports ragged arrays where rows can have different lengths (declared as int[][] rag = new int[3][];). This is because a 2D array is actually an array of array references.

IntermediateSingle Choice

What is printed?

int[][] m = {{1,2,3},{4,5,6}}; System.out.println(m.length + " " + m[0].length);

A. 3 2 B. 2 3 C. 6 3 D. 2 6

B is correct. The matrix has 2 rows (m.length = 2) and 3 columns (m[0].length = 3). Output: "2 3".

IntermediateSingle Choice

If you pass an array to a method and modify its elements inside the method, what happens to the original array?

A. Original is unchanged — arrays are passed by value B. Original IS changed — the reference is copied, elements are shared C. Compilation error — arrays cannot be passed to methods D. A copy of the array is automatically made

B is correct. When an array is passed to a method, the reference (address) is copied. Both the caller's variable and the method's parameter point to the same array object. So modifying arr[0] = 99 inside the method changes the original.

Hard

HardSingle Choice

What does Arrays.binarySearch(arr, key) return when the key is NOT found?

A. -1 B. arr.length C. A negative value: -(insertion point) - 1 D. 0

C is correct. When not found, Arrays.binarySearch returns -(insertion point) - 1, where the insertion point is where the key would be inserted to keep the array sorted. This is always a negative number, letting you distinguish "not found" from index 0.

HardMulti-Select

Which are TRUE about System.arraycopy(src, srcPos, dest, destPos, length)?

Select ALL that apply

A. src and dest can be the same array (overlapping copy) B. It creates a brand new array object C. srcPos is the starting index in the source array D. For primitive arrays, it performs a value (deep) copy E. length is the number of elements to copy

A, C, D, E are correct. B is false: System.arraycopy copies INTO an existing dest array — it does NOT create a new array. You must pre-allocate dest. It copies primitive values by value, making them independent for primitive arrays.

HardSingle Choice

What is the output?

int[] a = {1, 2, 3}; int[] b = a; b[0] = 99; System.out.println(a[0]);

A. 1 B. 99 C. Compilation error D. 0

B is correct. int[] b = a copies the reference, not the array. Both a and b point to the same array object in memory. So b[0] = 99 also changes a[0]. This is the classic "aliasing" problem.

HardSingle Choice

What is printed?

int[] arr = new int[5]; Arrays.fill(arr, 7); System.out.println(Arrays.toString(arr));

A. [0, 0, 0, 0, 0] B. [7, 7, 7, 7, 7] C. [7] D. Compilation error — must import Arrays

B is correct. Arrays.fill(arr, 7) sets every element to 7. Arrays.toString(arr) returns a formatted string like "[7, 7, 7, 7, 7]". Note: java.util.Arrays is automatically available with the import java.util.Arrays; statement (or java.util.*).

HardMulti-Select

When would you choose binary search over linear search?

Select ALL that apply

A. The array is already sorted B. The array is very large (performance matters) C. The array is unsorted and you cannot sort it D. You need O(log n) search performance E. The array has only 3 elements

A, B, D are correct. Binary search requires a sorted array (C is wrong). For tiny arrays (E), the overhead of sorting makes binary search impractical — linear search is fine for ≤10 elements. Binary search shines on large sorted datasets: 1 million elements → max 20 comparisons vs 1,000,000.

HardSingle Choice

What is printed?

int[] arr = {3, 1, 4, 1, 5, 9, 2, 6}; Arrays.sort(arr); System.out.println(arr[0] + " " + arr[arr.length-1]);

A. 3 6 B. 1 9 C. 3 9 D. 9 1

B is correct. After sorting ascending: {1, 1, 2, 3, 4, 5, 6, 9}. First element arr[0] = 1, last element arr[7] = 9. Output: "1 9".

HardMulti-Select

Which statements about Java arrays are TRUE?

Select ALL that apply

A. Arrays are objects in Java (stored on the heap) B. Array size is fixed after creation and cannot be changed C. A single array can store elements of different types D. Arrays.equals(a, b) compares element-by-element (content) E. You can create an array with length 0: new int[0]

A, B, D, E are correct. C is false: a typed array (e.g., int[]) can only store that type. To mix types, you'd use an Object[] or a collection like ArrayList. Note: a == b on arrays compares references; use Arrays.equals(a, b) for content comparison.

HardSingle Choice

What is printed?

int[][] m = {{1,2},{3,4},{5,6}}; int sum = 0; for (int[] row : m) { sum += row[0]; } System.out.println(sum);

A. 21 B. 9 C. 12 D. 6

B is correct. The loop accesses only column 0 of each row: row[0]=1, row[0]=3, row[0]=5. Sum = 1+3+5 = 9. The enhanced for-each treats each row as an int[].

Week 3 — Sorting & Searching

Selection Sort · Insertion Sort · Linear Search · Binary Search · Command-line Args

0 / 20

Easy

EasySingle Choice

What is the worst-case time complexity of linear search?

A. O(1) B. O(log n) C. O(n) D. O(n²)

C is correct. Linear search checks each element one by one. In the worst case (element not found or at the end), it checks all n elements → O(n). Best case: O(1) (first element). Average: O(n/2) = O(n).

EasySingle Choice

Which algorithm requires the array to be sorted before it can be used?

A. Selection Sort B. Insertion Sort C. Linear Search D. Binary Search

D is correct. Binary search relies on the array being sorted to eliminate half the remaining elements at each step. It gives wrong results on unsorted arrays. Linear search, selection sort, and insertion sort work on any array.

EasySingle Choice

In each pass of selection sort (ascending), what is done?

A. Adjacent elements are compared and swapped B. The minimum element in the unsorted portion is found and swapped to its correct position C. Each element is inserted into the correct position in the sorted portion D. The array is divided into two halves recursively

B is correct. Selection sort scans the unsorted portion, finds the minimum, and swaps it with the first unsorted element. After each pass, the sorted portion grows by 1. This makes at most n swaps total.

EasySingle Choice

What is the time complexity of binary search?

A. O(n) B. O(n²) C. O(log n) D. O(1)

C is correct. Binary search halves the search space with each comparison → O(log₂ n). For 1 million elements: only ~20 comparisons. This is why it's drastically faster than linear search O(n) on large sorted datasets.

EasySingle Choice

What does a typical linear search method return when the element is NOT found?

A. 0 B. null C. -1 D. arr.length

C is correct. By convention, a linear search that fails returns -1 (since -1 is never a valid array index). This is the same convention as String.indexOf() which also returns -1 when not found.

Intermediate

IntermediateSingle Choice

In insertion sort, what happens to the "current" element being processed?

A. It's swapped with the minimum element in the unsorted portion B. It's compared with elements in the sorted portion and inserted at the correct position C. It's removed and added to the end of the array D. It's compared only with the adjacent element

B is correct. Insertion sort picks the current element, then scans backwards through the already-sorted portion, shifting elements right until it finds the correct insertion spot. Think of sorting playing cards in your hand.

IntermediateMulti-Select

Which statements about selection sort are TRUE?

Select ALL that apply

A. Time complexity is O(n²) in all cases (best, average, worst) B. It performs at most n swaps total C. It is stable (preserves relative order of equal elements) D. In each pass it finds the minimum in the unsorted portion E. It is more efficient than insertion sort for nearly-sorted arrays

A, B, D are correct. C is false: selection sort is NOT stable (swapping can change relative order of equal elements). E is false: insertion sort is O(n) on nearly-sorted arrays — far better than selection sort's always-O(n²). Selection sort's advantage is minimum swaps.

IntermediateSingle Choice

After one complete pass of selection sort (ascending) on {5, 2, 8, 3, 1}, what is arr[0]?

A. 5 B. 2 C. 1 D. 3

C is correct. Pass 1: find minimum in {5,2,8,3,1} → min is 1 at index 4. Swap with index 0 (value 5). Array becomes {1, 2, 8, 3, 5}. So arr[0] = 1.

IntermediateSingle Choice

What is the maximum number of comparisons binary search needs for an array of 1024 elements?

A. 1024 B. 512 C. 11 D. 10

C is correct. Maximum comparisons = ⌊log₂(n)⌋ + 1 = ⌊log₂(1024)⌋ + 1 = 10 + 1 = 11. Each comparison halves the search space: 1024 → 512 → 256 → 128 → 64 → 32 → 16 → 8 → 4 → 2 → 1.

IntermediateMulti-Select

Which statements about binary search are TRUE?

Select ALL that apply

A. Requires the array to be sorted first B. Can be used via Arrays.binarySearch(arr, key) C. Works correctly on unsorted arrays D. Returns a negative value when the key is not found E. Has O(log n) time complexity

A, B, D, E are correct. C is false — binary search gives undefined/wrong results on unsorted arrays. Always sort first with Arrays.sort(arr) before calling Arrays.binarySearch().

IntermediateSingle Choice

To swap arr[i] and arr[j], which approach(es) work correctly?

A. arr[i] = arr[j]; arr[j] = arr[i]; B. Use a temp variable: int t=arr[i]; arr[i]=arr[j]; arr[j]=t; C. Arithmetic swap: arr[i]+=arr[j]; arr[j]=arr[i]-arr[j]; arr[i]-=arr[j]; D. Both B and C work correctly

D is correct. A is wrong (overwrites arr[i] before saving it — data is lost). B (temp variable) is the standard, clearest approach. C (arithmetic trick) also works for integers but can overflow for large values. Both B and C are correct swap methods.

IntermediateSingle Choice

What is the value of args.length when running: java MyProgram hello world 42?

A. 4 B. 3 C. 2 D. 0

B is correct. args contains only the arguments AFTER the class name: args[0]="hello", args[1]="world", args[2]="42" → args.length = 3. The class name MyProgram is NOT included in args.

Hard

HardMulti-Select

Which correctly compare insertion sort vs selection sort?

Select ALL that apply

A. Both have O(n²) worst-case time complexity B. Insertion sort performs better on nearly-sorted arrays C. Selection sort makes fewer comparisons overall D. Insertion sort can be O(n) in best case (already sorted) E. Selection sort makes at most n swaps total

A, B, D, E are correct. C is false: both make O(n²) comparisons in the worst case; neither makes fewer than the other in general. Insertion sort's key advantage: O(n) for already-sorted data. Selection sort's key advantage: at most n swaps (useful when write operations are expensive).

HardSingle Choice

After Arrays.sort(arr) on {4, 2, 7, 1, 9}, what does Arrays.binarySearch(arr, 7) return?

A. 2 B. 4 C. 3 D. -1

C is correct. After sorting: {1, 2, 4, 7, 9} (indices 0-4). Value 7 is at index 3. Arrays.binarySearch returns the index where the key is found.

HardSingle Choice

What is the state of {64, 25, 12, 22, 11} after ONE complete pass of selection sort (ascending)?

A. {11, 25, 12, 22, 64} B. {11, 64, 25, 12, 22} C. {25, 64, 12, 22, 11} D. {11, 12, 25, 22, 64}

A is correct. Pass 1: find min in entire array → min=11 at index 4. Swap with index 0 (value 64). Result: {11, 25, 12, 22, 64}. Only ONE swap happens per pass in selection sort.

HardMulti-Select

Which are valid uses of command-line arguments in Java? (public static void main(String[] args))

Select ALL that apply

A. String first = args[0]; B. int n = Integer.parseInt(args[1]); C. int count = args.length; D. System.out.println(args[0]); E. int count = args.length() + 1; // to include program name

A, B, C, D are correct. E is wrong for two reasons: (1) args.length is a field, not a method — no parentheses; (2) the program name is NOT in args at all, so you can't add 1 to get it. All arguments in args are Strings — use Integer.parseInt() or Double.parseDouble() to convert.

HardSingle Choice

What is the minimum number of comparisons binary search might need to find an element in a sorted array of 8 elements?

A. 1 B. 3 C. 4 D. 8

A is correct. Best case O(1): if the target is the middle element, it's found in 1 comparison. For an array of 8: middle index = 3 (or 4). If the key equals arr[3] on the first check — found in 1 comparison.

HardMulti-Select

In which situations is linear search preferable over binary search?

Select ALL that apply

A. The array is unsorted and you cannot sort it B. The array has only a few elements (e.g., 5–10) C. You cannot modify (sort) the array due to constraints D. The array has 10 million elements and is sorted E. You need the fastest possible search performance

A, B, C are correct. D and E both favor binary search. For large sorted arrays, binary search is dramatically faster. Linear search is practical when: the data is unsorted, the dataset is tiny, or sorting overhead/constraints prevent pre-sorting.

HardSingle Choice

Insertion sort processes {3, 1, 4, 1, 5}. In the third pass (inserting index 2, value = 4), what happens to element 4?

A. 4 is moved before 3 (inserted at index 0) B. 4 stays in place — no movement needed C. 4 is swapped with 1 D. 4 is moved to the end

B is correct. After passes 1&2: sorted portion = {1, 3}, remaining = {4, 1, 5}. Current element = 4. Compare 4 with 3: 4 > 3, so no shifting needed. 4 stays at index 2. Array = {1, 3, 4, 1, 5}.

HardMulti-Select

Which are TRUE about the java.util.Arrays class?

Select ALL that apply

A. Arrays.sort() modifies the original array in-place B. Arrays.sort() returns a new sorted array C. Arrays.equals(a, b) compares elements one by one D. Arrays.binarySearch() requires the array to be sorted first E. Arrays.toString(arr) returns a readable string like [1, 2, 3]

A, C, D, E are correct. B is false: Arrays.sort() returns void and sorts in-place. Common mistake: printing the return value of Arrays.sort() — it returns nothing.

Week 4 OOP — Classes, Objects & Encapsulation

0 / 20

EasySingle Choice

Which keyword is used to create a new object in Java?

A. create B. object C. new D. class

C is correct. The new keyword allocates memory and calls the constructor: Dog d = new Dog();

EasySingle Choice

Which access modifier makes a field inaccessible from outside the class?

A. public B. private C. protected D. default

B is correct. private fields are only accessible within the class they are declared in — the core idea behind encapsulation.

EasySingle Choice

Following Java naming conventions, what should a getter for a field called age be named?

A. getAge() B. age() C. Age() D. returnAge()

A is correct. Java convention: getters are named get + FieldName (capitalized). For boolean fields, use is prefix instead.

EasySingle Choice

A constructor must have the same name as ___.

A. The package B. The class C. The main method D. The first field declared

B is correct. A constructor's name must exactly match the class name and it has no return type — not even void.

EasySingle Choice

A static field in a class belongs to ___.

A. Each individual object B. The constructor only C. The class itself (shared by all objects) D. The subclass

C is correct. Static fields are class-level — all instances share the same copy. Common use: static int count = 0; to track how many objects were created.

IntermediateMulti Select

Which of the following are true about constructors? (Select all that apply)

A. A constructor has no return type B. A class can have multiple constructors (overloading) C. A constructor can be static D. If no constructor is defined, Java provides a default no-arg constructor E. A constructor must initialize all fields

A, B, D are correct. C is false — constructors cannot be static. E is false — fields get default values if not set (0, null, false).

IntermediateSingle Choice

Inside an instance method, what does the this keyword refer to?

A. The class itself B. The current object on which the method was called C. The superclass D. The static version of the field

B is correct. this is a reference to the current instance. It's commonly used to disambiguate between a parameter and a field: this.name = name;

IntermediateSingle Choice

What is encapsulation?

A. Putting all methods in one class B. Using inheritance to reuse code C. Hiding data with private fields and providing controlled access through public getters/setters D. Running multiple threads simultaneously

C is correct. Encapsulation bundles data (fields) and behavior (methods) together, exposing only what is necessary. It protects the internal state from invalid changes.

IntermediateSingle Choice

Given: class Car { private int speed; }
How can code outside the class read the value of speed?

A. Car.speed B. Via a public int getSpeed() method inside Car C. By changing private to static D. It cannot be read at all

B is correct. The standard encapsulation pattern: make fields private, provide a public getter. This lets the class control how data is exposed.

IntermediateMulti Select

Which of the following are true about static methods? (Select all that apply)

A. They cannot use this keyword B. They can directly access instance fields C. They can be called without creating an object D. They can access other static fields and methods directly E. They must have a return type of void

A, C, D are correct. B is false — static methods have no this, so they can't access instance fields directly. E is false — static methods can have any return type.

IntermediateSingle Choice

What is the default value of an uninitialized int instance field?

A. 0 B. null C. -1 D. Compile error

A is correct. Instance fields get default values automatically: int/long/short/byte → 0, double/float → 0.0, boolean → false, objects → null.

IntermediateMulti Select

Which statements about private access are correct? (Select all that apply)

A. A private method can be called from any class in the same package B. A private field can be accessed within the same class C. A private field cannot be directly accessed from a subclass D. private and protected mean the same thing E. Using private on fields is the foundation of encapsulation

B, C, E are correct. A is false — private restricts access to the declaring class only, not even same-package classes. D is false — protected allows subclass and same-package access.

HardSingle Choice

You define: class Box { Box(int size) { } }
Then call: Box b = new Box(); What happens?

A. Runs fine; Java provides a default no-arg constructor automatically B. size is set to 0 by default C. Compile error — the default no-arg constructor is removed once you define any constructor D. NullPointerException at runtime

C is correct. Java only provides a free no-arg constructor when you write no constructor at all. Once you define any constructor, the default is gone. Fix: add Box() { } explicitly.

HardSingle Choice

What is the output of the following code?

String s = null;
System.out.println(s.length());

A. 0 B. NullPointerException at runtime C. Compile error D. null

B is correct. s holds null — no object. Calling any method on null throws NullPointerException at runtime. Always check for null before calling methods on object references.

HardMulti Select

Which statements correctly distinguish instance variables from static variables? (Select all that apply)

A. Each object has its own copy of an instance variable B. Static variables are destroyed when the object is garbage-collected C. All objects share the same static variable D. A static variable exists even before any object is created E. Instance variables can be accessed without an object reference

A, C, D are correct. B is false — static variables live as long as the class is loaded, not tied to any object's lifecycle. E is false — instance variables require an object reference to access.

HardSingle Choice

Consider this class. What does calling new Counter() then new Counter() produce for Counter.count?

class Counter {
  static int count = 0;
  Counter() { count++; }
}

A. 0 B. 1 C. Each object has its own count equal to 1 D. 2 — the same static field was incremented twice

D is correct. count is static, shared by all objects. Each constructor call increments the same counter. After two new Counter() calls, Counter.count == 2. This is a classic pattern to count how many instances were created.

HardSingle Choice

What does this(10) do when placed as the first line of a constructor?

A. Calls another constructor in the same class that accepts an int parameter B. Sets all fields to 10 C. Calls the parent class constructor D. Throws a compile error because this can't take arguments

A is correct. this(...) is constructor chaining — it delegates to another constructor in the same class. It must be the very first statement. super(...) is used to call the parent constructor.

HardMulti Select

Which of the following are genuine benefits of encapsulation? (Select all that apply)

A. You can validate data before setting a field (e.g., reject negative ages) B. Internal implementation can change without affecting external code C. It makes the program run faster D. It prevents external code from putting the object into an invalid state E. It removes the need for constructors

A, B, D are correct. Setters let you add validation logic. Internal refactoring doesn't break callers since they only see the public API. C is false — encapsulation is about safety, not performance. E is false — constructors are still essential.

HardSingle Choice

What is the output of the following code?

class Dog {
  String name;
  Dog(String name) { this.name = name; }
  void bark() { System.out.println(name + " says woof"); }
}
// In main:
Dog d1 = new Dog("Rex");
Dog d2 = d1;
d2.name = "Max";
d1.bark();

A. Rex says woof B. Max says woof C. null says woof D. Compile error

B is correct. d2 = d1 copies the reference, not the object. Both d1 and d2 point to the same object in memory. Changing d2.name also changes what d1.name sees — they are aliases.

HardMulti Select

Which of the following correctly describe the relationship between a class and an object? (Select all that apply)

A. A class is an instance of an object B. An object is an instance of a class C. Multiple objects can be created from the same class D. Each object stores the class's source code at runtime E. A class defines the blueprint; objects are the actual things built from it

B, C, E are correct. A is reversed — the class is the blueprint, the object is the instance. D is false — objects store field values, not source code. Think of a class as a cookie cutter and objects as the cookies.

Week 5 Thinking in Objects — Strings, Wrappers & Composition

0 / 20

EasySingle Choice

In Java, String objects are ___.

A. Mutable — you can change their characters directly B. Immutable — once created, their value cannot be changed C. Mutable only when declared with final D. Neither mutable nor immutable

B is correct. String is immutable. Methods like toUpperCase() return a new String — they don't modify the original. This is why Strings are safe to share.

EasySingle Choice

Which method should you use to compare the content of two String objects?

A. == B. compareTo() C. equals() D. equalsTo()

C is correct. == compares references (memory addresses). equals() compares actual character content. compareTo() returns an ordering, not equality.

EasySingle Choice

What is autoboxing in Java?

A. Automatic conversion from a primitive type to its wrapper class (e.g., int → Integer) B. Converting a String to an int C. Packing arrays into objects D. Storing objects inside another object

A is correct. Autoboxing: Integer i = 42; — Java wraps 42 into an Integer object automatically. Unboxing is the reverse: int n = i;

EasySingle Choice

Which method converts the String "42" to the int value 42?

A. Integer.toString("42") B. Integer.parseInt("42") C. String.toInt("42") D. (int) "42"

B is correct. Integer.parseInt(String) parses a numeric string into an int. If the string isn't a valid integer, it throws NumberFormatException.

EasySingle Choice

What does "Hello".length() return?

A. 4 B. 6 C. 5 D. Compile error — length is a field, not a method, for Strings

C is correct. "Hello" has 5 characters, so length() returns 5. Note: for arrays, length is a field (no parentheses); for Strings and ArrayLists, length()/size() are methods.

IntermediateSingle Choice

What is the output of this code?

String a = "hello";
String b = "hello";
String c = new String("hello");
System.out.println(a == b);
System.out.println(a == c);

A. true then true B. true then false C. false then false D. false then true

B is correct. String literals a and b point to the same interned object in the String pool → true. new String(...) forces a new heap object → a == c is false. Always use .equals() to compare content.

IntermediateMulti Select

Which of the following are valid String methods in Java? (Select all that apply)

A. s.append("text") B. s.substring(2, 5) C. s.toUpperCase() D. s.startsWith("He") E. s.push('x')

B, C, D are correct. A is false — append() belongs to StringBuilder, not String. E is false — push() is a Stack method, not String. String's main methods: length(), charAt(), substring(), indexOf(), toUpperCase(), toLowerCase(), trim(), startsWith(), endsWith(), contains().

IntermediateSingle Choice

What is the difference between composition and aggregation?

A. They are the same thing B. Aggregation means the child cannot exist without the parent C. Composition means the child's lifetime is tied to the parent; aggregation allows the child to exist independently D. Composition is only used with static fields

C is correct. Composition (strong ownership): a Room inside a House — destroy the house, rooms are gone. Aggregation (weak ownership): a Student in a Course — delete the course, the student still exists.

IntermediateSingle Choice

What does "Hello World".substring(6) return?

A. "World" B. "Hello" C. "World " D. " World"

A is correct. substring(6) returns all characters from index 6 to end. Indices: H=0, e=1, l=2, l=3, o=4, (space)=5, W=6. So index 6 is 'W' → "World".

IntermediateMulti Select

Which are true about wrapper classes like Integer, Double, Boolean? (Select all that apply)

A. They allow primitives to be used where objects are required (e.g., collections) B. They are mutable objects C. They provide utility methods like Integer.parseInt() D. Each primitive type has a corresponding wrapper class E. They are faster than primitives at runtime

A, C, D are correct. B is false — wrapper classes are immutable, just like String. E is false — primitives are faster; wrappers add object overhead. Wrapper classes: int→Integer, double→Double, char→Character, boolean→Boolean, etc.

IntermediateSingle Choice

An immutable class should have ___. (Choose the best description)

A. All fields public and no constructor B. All fields private final, no setters, and initialize via constructor C. A static block that resets fields periodically D. Getter methods that return new random values

B is correct. Rules for an immutable class: (1) declare fields private final, (2) initialize via constructor, (3) provide no setter methods, (4) make the class final to prevent subclassing that breaks immutability.

IntermediateMulti Select

A Library class has a field List<Book> books. Which of the following correctly describe this as a composition relationship? (Select all that apply)

A. Library creates and owns the Book objects B. When the Library is destroyed, its Book objects are also destroyed C. Book objects can be freely shared between multiple libraries D. Book objects exist independently of any Library E. This represents a "has-a" relationship

A, B, E are correct. In composition, the child's lifecycle is tied to the parent. C and D describe aggregation, where the child can outlive or be shared beyond the parent.

HardSingle Choice

What is the output of this code?

String s = "Java";
s.concat(" Programming");
System.out.println(s);

A. Java Programming B. Compile error C. Java D. null

C is correct. Strings are immutable. concat() returns a new String but the result is discarded. s still points to "Java". Fix: s = s.concat(" Programming");

HardSingle Choice

What does this print?

Integer x = 127;
Integer y = 127;
Integer a = 128;
Integer b = 128;
System.out.println(x == y);
System.out.println(a == b);

A. true then true B. true then false C. false then false D. Compile error

B is correct. Java caches Integer objects in the range −128 to 127. So x and y share the same cached object → true. For 128 and above, new objects are created → a == b is false. Always use .equals() with wrapper types.

HardMulti Select

Which of the following are true about Java garbage collection? (Select all that apply)

A. You can force garbage collection by calling delete obj; B. An object becomes eligible for GC when no references point to it C. Garbage collection runs automatically; you cannot control exactly when D. Setting an object to null immediately frees memory E. System.gc() is a hint to the JVM to run GC, not a guarantee

B, C, E are correct. A is false — Java has no delete. D is false — setting to null makes the object eligible for GC, but memory isn't freed instantly; the GC decides when to reclaim it.

HardSingle Choice

What does this print?

String s = "  Hello  ";
System.out.println(s.trim().toLowerCase().charAt(1));

A. H B. h C. e D. e

D is correct. Step by step: (1) trim() → "Hello", (2) toLowerCase() → "hello", (3) charAt(1) → index 1 = 'e'. Method chaining works because each String method returns a new String.

HardMulti Select

Which of the following correctly describe how StringBuilder differs from String? (Select all that apply)

A. StringBuilder is mutable; you can modify its content in place B. StringBuilder objects can be used as keys in a HashMap safely C. StringBuilder.append() modifies the existing object and returns this D. Using StringBuilder in a loop is more efficient than concatenating Strings with + E. StringBuilder is immutable like String

A, C, D are correct. B is false — StringBuilder is mutable, so its hashCode can change, making it unreliable as a map key. E is false — immutability is a String trait, not StringBuilder.

HardSingle Choice

A Person class contains an Address object as a field. The Address can be shared across multiple Person objects. This is an example of ___.

A. Composition — the Address is owned exclusively by the Person B. Inheritance — Person extends Address C. Aggregation — the Address can exist independently and be shared D. Encapsulation — Address fields are private

C is correct. When the contained object can be shared and survives the container, it's aggregation (weak "has-a"). If Person created and exclusively owns the Address, that would be composition (strong "has-a").

HardMulti Select

Which of the following produce a NumberFormatException at runtime? (Select all that apply)

A. Integer.parseInt("12.5") B. Integer.parseInt("") C. Integer.parseInt("99") D. Integer.parseInt("abc") E. Double.parseDouble("3.14")

A, B, D are correct. parseInt requires a whole number string. "12.5" has a decimal point, "" is empty, "abc" is not a number — all throw NumberFormatException. C and E are valid: "99" is a valid int, "3.14" is a valid double.

HardMulti Select

Which of the following are properties of a well-designed immutable class? (Select all that apply)

A. Fields are public so values can be read quickly B. All fields are declared private final C. It provides setter methods so callers can update values D. The class is declared final to prevent subclasses from overriding behavior E. All values are set through the constructor and never changed after

B, D, E are correct. A is wrong — fields must be private to prevent external mutation. C directly breaks immutability — setters are forbidden. A truly immutable class: final class, private final fields, constructor-only initialization, no setters.

Week 6 — Mid Review

Select Weeks to Include

Review Results

Week 4 OOP — Classes, Objects & Encapsulation

Week 5 Thinking in Objects — Strings, Wrappers & Composition