ASSIGNMENT 1:

Task 1:
Review the following codes, find and fix errors also explain the errors

Debugging Exercise 1: Array Manipulation

Objective: To identify and fix errors in a Java program that manipulates arrays.

public class ArrayManipulation {

( public static void main(String[] args) {

int[] numbers = (1, 2, 3, 4, 5);

for (int i = 0; i<= numbers.length; i++) {

System.out.println(numbers[i]):

Error:
1. Array Initialization
2. For Loop Condition

Corrected code:
public class ArrayManipulation {

public static void main(String[] args) {

int[] numbers = {1, 2, 3, 4, 5}; // Correct way to initialize an array using curly braces

for (int i = 0; i < numbers.length; i++) { // Corrected loop condition

System.out.println(numbers[i]); // Corrected println statement and removed colon

Errors explained:
 1. Array Initialization: Arrays in Java are initialized using curly braces {} and not parentheses
(). So, int[] numbers = {1, 2, 3, 4, 5}; initializes an array of integers with 5
elements containing the values 1 through 5.
2. For Loop Condition: The condition in the for loop should be i < numbers.length
instead of i <= numbers.length. This is because array indexing in Java starts from 0,
so numbers.length gives the number of elements in the array, but indexing goes from 0
to numbers.length - 1.

Debugging Exercise 2: Object-Oriented Programming

Objective: To identify and fix errors in a Java program that demonstrates basic object-
oriented programming principles.

class Car {

private String make;

private String model;

public Car(String make, String model) {

this.make = make;

this.model = model;

public void start() {

System.out.println("Starting the car.");

public class Main {

public static void main(String[] args) {

Car car = new Car("Toyota", "Camry");

car.start();

car.stop();

Errors:

Missing stop() Method in Car Class

Corrected code:
class Car {

private String make;

private String model;

public Car(String make, String model) {

this.make = make;

this.model = model;

public void start() {

System.out.println("Starting the car.");

// Adding a stop method

public void stop() {

System.out.println("Stopping the car.");

public class Main {

public static void main(String[] args) {

Car car = new Car("Toyota", "Camry");

car.start();

car.stop();

Error explained:
 Encapsulation: The Car class now encapsulates both start() and stop() methods, which
are behaviors related to the car object. This adheres to the principle of encapsulation in object-
oriented programming by bundling related behaviors together within the Car class.
 Object Initialization: In the main method of the Main class, a Car object named car is
instantiated with the make "Toyota" and model "Camry". This demonstrates the creation of objects
based on a class definition.

 Method Invocation: The car.start(); and car.stop(); lines in the main method
demonstrate invoking methods on the car object, showing how objects interact with their behaviors
(methods) to perform actions (starting and stopping).

Debugging Exercise 3: Exception Handling

Objective: To identify and fix errors in a Java program that demonstrates exception handling.

public class ExceptionHandling {

public static void main(String[] args) {

int[] numbers = {1, 2, 3, 4, 5);

try {

System.out.println(numbers[10]);

} catch (ArrayIndexOutOfBoundsException e) {

System.out.println("Array index out of bounds.");

int result = divide(10, 0);

System.out.println("Result: " + result);

public static int divide(int a, int b) {

return a/b;

Errors:
1. Array Index Out of Bounds Exception Handling
2. Arithmetic Exception Handling
Corrected error:
public class ExceptionHandling {

public static void main(String[] args) {

int[] numbers = {1, 2, 3, 4, 5};

try {

System.out.println(numbers[10]); // Trying to access index 10 which doesn't exist

} catch (ArrayIndexOutOfBoundsException e) {

System.out.println("Array index out of bounds.");

// Handling ArithmeticException by catching it

try {

int result = divide(10, 0); // Trying to divide by zero

System.out.println("Result: " + result); // This line will not be reached if an exception occurs

} catch (ArithmeticException e) {

System.out.println("Cannot divide by zero.");

public static int divide(int a, int b) {

if (b == 0) {

throw new ArithmeticException("Divisor cannot be zero"); // Throw an exception if b is 0

return a / b;

Errors explained:

 Try-Catch Blocks: Both try-catch blocks are used to handle specific types of exceptions:
  The first try-catch block handles ArrayIndexOutOfBoundsException when
accessing an invalid index in the numbers array.
 The second try-catch block handles ArithmeticException when attempting to
divide by zero in the divide method.

 Method Invocation: The main method invokes divide(10, 0);, demonstrating how
exceptions thrown from methods are caught and handled in Java.

 Output: With proper exception handling, even if an exception occurs (like dividing by zero), the
program gracefully handles it by printing an appropriate error message .

Exercise 4:

public class Fibonacci {

public static int fibonacci(int n) {

if (n <= 1)

return n;

else

return fibonacci(n-1) + fibonacci(n-2);

public static void main(String[] args) {

int n = 6;

int result = fibonacci(n);

System.out.println("The Fibonacci number at position" + n + " is: " + result);

The code aims to calculate the Fibonacci sequence. However, there is a bug in the code.
When the student runs this code, it will raise an error or produce incorrect output. The
student's task is to identify and correct the bug.

Errors:

1. Memoization Implementation
2. Efficient Computation

Corrected code:
import java.util.HashMap;
import java.util.Map;

public class Fibonacci {

// Memoization map to store computed Fibonacci numbers

private static Map<Integer, Integer> memo = new HashMap<>();

public static int fibonacci(int n) {

if (n <= 1)

return n;

// Check if Fibonacci number for 'n' is already computed

if (memo.containsKey(n)) {

return memo.get(n);

} else {

// Compute Fibonacci number and store in memoization map

int fib = fibonacci(n - 1) + fibonacci(n - 2);

memo.put(n, fib);

return fib;

public static void main(String[] args) {

int n = 6;

int result = fibonacci(n);

System.out.println("The Fibonacci number at position " + n + " is: " + result);

Errors explained:

 Memoization: By storing previously computed results, the Fibonacci sequence is computed

efficiently without recomputing values multiple times.
 Recursive Approach: The recursive structure remains intact (fibonacci(n) =
fibonacci(n-1) + fibonacci(n-2)), but with the added benefit of caching results for
quick lookup.

 Output: When you run the modified main method, it correctly computes and prints the Fibonacci
number at position n (in this case, n = 6), demonstrating the corrected and optimized Fibonacci
sequence calculation.

Exercise5:
import java.util.*;

public class PrimeNumbers (

public static List<Integer> findPrimes(int n) {

List<Integer> primes = new ArrayList<>();

for (int i = 2; i <= n; i++) {

boolean is Prime = true;

for (int j = 2; j<i; j++) {

if (i % j == 0) {

isPrime = false;

break;

if (isPrime) {

primes.add(i);

return primes;

public static void main(String[] args) {

int n = 20;

List<Integer> primeNumbers = findPrimes(n);

System.out.println("Prime numbers up to +n+":"+ primeNumbers);

}
The code aims to find prime numbers up to a given limit. However, there is a bug in the
code. When the student runs this code, it will raise an error or produce incorrect output. The
student's task is to identify and correct the bug.

Errors:
1. Prime Number Check: In the findPrimes method:

 Correction in Loop:
 Edge Case Handling:

2. Output Formatting: In the main method

Corrected code:

import java.util.*;

public class PrimeNumbers {

public static List<Integer> findPrimes(int n) {

List<Integer> primes = new ArrayList<>();

// Edge case for smaller values of n

if (n < 2) {

return primes; // Return empty list for n < 2

for (int i = 2; i <= n; i++) {

boolean isPrime = true;

// Check for factors of i from 2 to sqrt(i)

for (int j = 2; j <= Math.sqrt(i); j++) {

if (i % j == 0) {

isPrime = false;

break;

}
 }

if (isPrime) {

primes.add(i);

return primes;

public static void main(String[] args) {

int n = 20;

List<Integer> primeNumbers = findPrimes(n);

System.out.println("Prime numbers up to " + n + ": " + primeNumbers);

Errors explained:

 Prime Number Check: The corrected implementation iterates through numbers from 2 to n and
checks if each number is prime by testing divisibility from 2 up to its square root. This is more
efficient than testing divisibility up to i - 1.

 Edge Case Handling: Handling the case where n is less than 2 ensures the function returns an
empty list, as there are no prime numbers less than 2.

 Output: The main method now correctly prints the list of prime numbers found up to the
specified limit n, formatted for clarity.