Experiment 1.3: Input Validation, ATM Withdrawal System, and University Enrolment

Abstract Classes and Methods

Data abstraction is the process of hiding certain details and showing only essential information to the user.

Abstraction can be achieved with either abstract classes or interfaces. The abstract keyword is a non-access modifier, used for classes and methods:

• Abstract class - a restricted class that cannot be used to create objects. To access it, it must be inherited from another class.
• Abstract method - can only be used in an abstract class, and it does not have a body. The body is provided by the subclass.

An abstract class can have both abstract and regular methods:

abstract class Animal {
    public abstract void animalSound();

    public void sleep() {
        System.out.println("Zzz");
    }
}

From the example above, it is not possible to create an object of the Animal class:

Animal myObj = new Animal();   // will generate an error

To access the abstract class, it must be inherited from another class. Remember from the Inheritance chapter that we use the extends keyword to inherit from a class:

// Abstract class
abstract class Animal {
    // Abstract method (does not have a body)
    public abstract void animalSound();

    // Regular method
    public void sleep() {
        System.out.println("Zzz");
    }
}

// Subclass (inherit from Animal)
class Pig extends Animal {
    public void animalSound() {
        // The body of animalSound() is provided here
        System.out.println("The pig says: wee wee");
    }
}

class Main {
    public static void main(String[] args) {
        Pig myPig = new Pig();   // Create a Pig object
        myPig.animalSound();
        myPig.sleep();
    }
}

Why and when to use abstract classes and methods? To achieve security - hide certain details and only show the important details of an object.

Java Exceptions - Try...Catch

When executing Java code, different errors can occur: coding errors made by the programmer, errors due to wrong input, or other unforeseeable things.

When an error occurs, Java will normally stop and generate an error message. The technical term for this is: Java will throw an exception.

The try statement allows you to define a block of code to be tested for errors while it is being executed. The catch statement allows you to define a block of code to be executed if an error occurs in the try block. The try and catch keywords come in pairs:

try {
    // Block of code to try
}
catch (Exception e) {
    // Block of code to handle errors
}

The following statement attempts to access an invalid array index and therefore throws an ArrayIndexOutOfBoundsException:

public class Main {
    public static void main(String[] args) {
        int[] myNumbers = {1, 2, 3};
        System.out.println(myNumbers[10]);   // error!
    }
}

Sample output:

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 10
        at Main.main(Main.java:4)

A try-catch block can catch the exception and execute suitable handling code:

public class Main {
    public static void main(String[] args) {
        try {
            int[] myNumbers = {1, 2, 3};
            System.out.println(myNumbers[10]);
        } catch (Exception e) {
            System.out.println("Something went wrong.");
        }
    }
}

Sample output:

Something went wrong.

Finally

The finally statement lets you execute code after try...catch, regardless of the result:

public class Main {
    public static void main(String[] args) {
        try {
            int[] myNumbers = {1, 2, 3};
            System.out.println(myNumbers[10]);
        } catch (Exception e) {
            System.out.println("Something went wrong.");
        } finally {
            System.out.println("The 'try catch' is finished.");
        }
    }
}

Sample output:

Something went wrong.
The 'try catch' is finished.

The throw Keyword

The throw statement allows you to create a custom error. It is used together with an exception type. There are many exception types available in Java: ArithmeticException, FileNotFoundException, ArrayIndexOutOfBoundsException, SecurityException, and so on.

Throw an exception if age is below 18 (print "Access denied"). If age is 18 or older, print "Access granted":

public class Main {
    static void checkAge(int age) {
        if (age < 18) {
            throw new IllegalArgumentException("Access denied - You must be at least 18 years old.");
        } else {
            System.out.println("Access granted - You are old enough!");
        }
    }

    public static void main(String[] args) {
        checkAge(15);   // Set age to 15 (which is below 18...)
    }
}

Sample output:

Exception in thread "main" java.lang.IllegalArgumentException: Access denied - You must be at least 18 years old.
        at Main.checkAge(Main.java:4)
        at Main.main(Main.java:12)

If age was 20, you would not get an exception:

checkAge(20);

Sample output:

Access granted - You are old enough!

In Experiments 1.1 and 1.2 a bad input simply crashed the program. This experiment is about the opposite: the program stays in control and decides what happens when something goes wrong. Revise these ideas before writing any code.

Throwable
  +-- Error                  // OutOfMemoryError - do not catch
  +-- Exception              // recoverable
        +-- IOException      // checked
        +-- RuntimeException // unchecked
              +-- ArithmeticException
              +-- IllegalArgumentException

class InvalidPinException extends Exception { }
// checked: callers are forced to handle it

class BadInput extends RuntimeException { }
// unchecked: the compiler stays silent

try {
    risky();
} catch (Exception e) {
    System.out.println(e.getMessage());
} finally {
    scanner.close();   // always runs
}

catch (IllegalArgumentException e) { ... }  // specific first
catch (Exception e) { ... }                 // general last

catch (InvalidPinException | InsufficientBalanceException e) { ... }

public void enrollStudent(Set<String> done)
        throws CourseFullException {      // declares
    if (full) {
        throw new CourseFullException(msg);  // raises
    }
}

class CourseFullException extends Exception {
    public CourseFullException(String message) {
        super(message);   // hand it to Throwable
    }
}

double n = scanner.nextDouble();
// user types: abc
// -> java.util.InputMismatchException
// caught by catch (Exception e)

throw new InvalidPinException("Error: Invalid PIN. Please try again.");
...
catch (InvalidPinException e) {
    System.out.println(e.getMessage());
    // prints: Error: Invalid PIN. Please try again.
}

Problem statement: Write a Java program to calculate the square root of a number entered by the user. Use try-catch to handle invalid inputs (e.g., negative numbers or non-numeric values).

Algorithm

1. Start the program and create a Scanner object.
2. Open a try block and prompt for a number, reading it with nextDouble().
3. If the number is negative, throw new IllegalArgumentException with an explanatory message.
4. Otherwise compute Math.sqrt(number) and print the result.
5. Catch IllegalArgumentException first and print e.getMessage().
6. Catch Exception next to cover non-numeric input, and print the invalid-input message.
7. Close the scanner in finally so it happens on every path, then end the program.

Java Program

import java.util.Scanner;

public class SquareRootCalculator {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        try {
            // Taking user input
            System.out.print("Enter a number: ");
            double number = scanner.nextDouble();

            // Handling negative numbers
            if (number < 0) {
                throw new IllegalArgumentException("Error: Cannot calculate the square root of a negative number.");
            }

            // Calculating square root
            double result = Math.sqrt(number);
            System.out.println("Square root: " + result);
        } catch (IllegalArgumentException e) {
            // Specific clause: must come before catch (Exception e)
            System.out.println(e.getMessage());
        } catch (Exception e) {
            // Reached when Scanner throws InputMismatchException
            System.out.println("Error: Invalid input. Please enter a valid number.");
        } finally {
            scanner.close();
        }
    }
}

Sample Output

Run 1 - a valid number:

Enter a number: 625
Square root: 25.0

Run 2 - a negative number (your own throw fires):

Enter a number: -49
Error: Cannot calculate the square root of a negative number.

Run 3 - non-numeric input (Scanner throws):

Enter a number: abc
Error: Invalid input. Please enter a valid number.

Problem statement: Write a Java program to simulate an ATM withdrawal system. The program should ask the user to enter their PIN, allow the withdrawal if the PIN is correct and the balance is sufficient, throw exceptions for an invalid PIN or insufficient balance, and ensure the system always shows the remaining balance, even if an exception occurs.

Algorithm

1. Declare CORRECT_PIN as a static final int and balance as a static double set to 3000.0.
2. Write InvalidPinException and InsufficientBalanceException, each extending Exception and passing its message to super.
3. Inside a try block, read the PIN with nextInt().
4. If the PIN does not match, throw new InvalidPinException - the amount is never requested.
5. Read the withdrawal amount with nextDouble().
6. If the amount exceeds the balance, throw new InsufficientBalanceException and leave the balance untouched.
7. Otherwise subtract the amount and print the success message with the new balance.
8. Handle both custom types in a single multi-catch clause and print e.getMessage().
9. Add a general catch (Exception e) for non-numeric input.
10. In finally, print Current Balance: and close the scanner.

Java Program

import java.util.Scanner;

// Custom exception for invalid PIN
class InvalidPinException extends Exception {
    public InvalidPinException(String message) {
        super(message);   // hand the message to Throwable so getMessage() can return it
    }
}

// Custom exception for insufficient balance
class InsufficientBalanceException extends Exception {
    public InsufficientBalanceException(String message) {
        super(message);
    }
}

public class ATMWithdrawalSystem {

    private static final int CORRECT_PIN = 1234;   // Predefined PIN
    private static double balance = 3000.0;        // Initial balance

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        try {
            // Asking user to enter PIN
            System.out.print("Enter PIN: ");
            int enteredPin = scanner.nextInt();

            // Validate PIN
            if (enteredPin != CORRECT_PIN) {
                throw new InvalidPinException("Error: Invalid PIN. Please try again.");
            }

            // Asking user for withdrawal amount
            System.out.print("Withdraw Amount: ");
            double withdrawAmount = scanner.nextDouble();

            // Check for sufficient balance
            if (withdrawAmount > balance) {
                throw new InsufficientBalanceException("Error: Insufficient balance.");
            }

            // Perform withdrawal
            balance -= withdrawAmount;
            System.out.println("Withdrawal Successful! Remaining Balance: " + balance);

        } catch (InvalidPinException | InsufficientBalanceException e) {
            // Multi-catch: one clause, two unrelated exception types
            System.out.println(e.getMessage());
        } catch (Exception e) {
            System.out.println("Error: Invalid input. Please enter numeric values.");
        } finally {
            // Runs whether the withdrawal succeeded or an exception was thrown
            System.out.println("Current Balance: " + balance);
            scanner.close();
        }
    }
}

Sample Output

Run 1 - correct PIN, sufficient balance:

Enter PIN: 1234
Withdraw Amount: 1200
Withdrawal Successful! Remaining Balance: 1800.0
Current Balance: 1800.0

Run 2 - wrong PIN (gate 1 fails, the amount is never asked for):

Enter PIN: 9999
Error: Invalid PIN. Please try again.
Current Balance: 3000.0

Run 3 - correct PIN, amount larger than the balance:

Enter PIN: 1234
Withdraw Amount: 5000
Error: Insufficient balance.
Current Balance: 3000.0

Problem statement: Create a Java program for a university enrolment system with exception handling. The program should read enrolment requests from the user, throw a CourseFullException when the maximum enrolment limit is reached, and throw a PrerequisiteNotMetException when the student has not completed the prerequisite course.

Algorithm

1. Define CourseFullException and PrerequisiteNotMetException as checked exceptions by extending Exception.
2. Create a Student class with student id, name, and a Set<String> for completed courses.
3. Add completeCourse and hasCompletedCourse methods in Student.
4. Create a Course class with course code, course name, maximum enrolment limit, prerequisite course, and an enrolled-student list.
5. Declare enrollStudent(Student student) with throws CourseFullException, PrerequisiteNotMetException.
6. In enrollStudent, throw CourseFullException if the enrolled-student list has already reached the maximum limit.
7. If seats are available, check the prerequisite. Throw PrerequisiteNotMetException when the prerequisite is required but absent from the student's completed-course set.
8. Read the number of enrolment requests from the user.
9. For each request, read student id, student name, and whether the student has completed the prerequisite course.
10. Call attemptEnrollment for every student. It calls enrollStudent inside try, catches both custom exceptions in one multi-catch block, and prints available seats in finally.
11. Close the scanner in finally after all enrolment requests have been processed.

Java Program

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Scanner;
import java.util.Set;

class CourseFullException extends Exception {
    public CourseFullException(String message) {
        super(message);
    }
}

class PrerequisiteNotMetException extends Exception {
    public PrerequisiteNotMetException(String message) {
        super(message);
    }
}

class Student {
    private final String studentId;
    private final String name;
    private final Set<String> completedCourses;

    public Student(String studentId, String name) {
        this.studentId = studentId;
        this.name = name;
        this.completedCourses = new HashSet<>();
    }

    public void completeCourse(String courseName) {
        completedCourses.add(courseName);
    }

    public boolean hasCompletedCourse(String courseName) {
        return completedCourses.contains(courseName);
    }

    public String getName() {
        return name;
    }

    public String getStudentId() {
        return studentId;
    }
}

class Course {
    private final String courseCode;
    private final String courseName;
    private final int maxEnrollment;
    private final String prerequisiteCourse;
    private final List<Student> enrolledStudents;

    public Course(String courseCode, String courseName,
                  int maxEnrollment, String prerequisiteCourse) {
        this.courseCode = courseCode;
        this.courseName = courseName;
        this.maxEnrollment = maxEnrollment;
        this.prerequisiteCourse = prerequisiteCourse;
        this.enrolledStudents = new ArrayList<>();
    }

    public void enrollStudent(Student student)
            throws CourseFullException, PrerequisiteNotMetException {

        if (enrolledStudents.size() >= maxEnrollment) {
            throw new CourseFullException(courseCode + " - " + courseName
                    + " is full. Maximum enrolment limit is " + maxEnrollment + ".");
        }

        if (prerequisiteCourse != null
                && !prerequisiteCourse.trim().isEmpty()
                && !student.hasCompletedCourse(prerequisiteCourse)) {
            throw new PrerequisiteNotMetException(student.getName()
                    + " must complete " + prerequisiteCourse
                    + " before enrolling in " + courseName + ".");
        }

        enrolledStudents.add(student);
        System.out.println(student.getName() + " (" + student.getStudentId()
                + ") enrolled in " + courseName + ".");
    }

    public String getCourseName() {
        return courseName;
    }

    public String getPrerequisiteCourse() {
        return prerequisiteCourse;
    }

    public int getAvailableSeats() {
        return maxEnrollment - enrolledStudents.size();
    }
}

public class UniversityEnrollmentSystem {
    private static int readEnrollmentCount(Scanner scanner) {
        while (true) {
            System.out.print("How many students want to enroll? ");
            try {
                int count = Integer.parseInt(scanner.nextLine().trim());
                if (count > 0) {
                    return count;
                }
                System.out.println("Enter a number greater than zero.");
            } catch (NumberFormatException e) {
                System.out.println("Enter a valid whole number.");
            }
        }
    }

    private static boolean readYesNo(Scanner scanner, String prompt) {
        while (true) {
            System.out.print(prompt);
            String answer = scanner.nextLine().trim().toLowerCase();
            if (answer.equals("yes") || answer.equals("y")) {
                return true;
            }
            if (answer.equals("no") || answer.equals("n")) {
                return false;
            }
            System.out.println("Please type yes or no.");
        }
    }

    private static Student readStudent(Scanner scanner, int studentNumber, Course course) {
        System.out.println("\nStudent " + studentNumber + " details");
        System.out.print("Enter student id: ");
        String id = scanner.nextLine().trim();

        System.out.print("Enter student name: ");
        String name = scanner.nextLine().trim();

        Student student = new Student(id, name);
        String prerequisite = course.getPrerequisiteCourse();

        if (prerequisite != null && !prerequisite.trim().isEmpty()) {
            boolean completed = readYesNo(scanner,
                    "Has the student completed " + prerequisite + "? (yes/no): ");
            if (completed) {
                student.completeCourse(prerequisite);
            }
        }

        return student;
    }

    private static void attemptEnrollment(Course course, Student student) {
        System.out.println("Trying to enroll " + student.getName()
                + " in " + course.getCourseName());

        try {
            course.enrollStudent(student);
        } catch (CourseFullException | PrerequisiteNotMetException e) {
            System.out.println("Enrollment failed: " + e.getMessage());
        } finally {
            System.out.println("Seats left in " + course.getCourseName()
                    + ": " + course.getAvailableSeats());
        }
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        Course advancedJava = new Course("CS302", "Advanced Java", 2, "Core Java");

        try {
            int totalStudents = readEnrollmentCount(scanner);

            for (int i = 1; i <= totalStudents; i++) {
                Student student = readStudent(scanner, i, advancedJava);
                attemptEnrollment(advancedJava, student);
            }
        } finally {
            scanner.close();
        }
    }
}

Sample Output

How many students want to enroll? 4

Student 1 details
Enter student id: S101
Enter student name: Ananya
Has the student completed Core Java? (yes/no): yes
Trying to enroll Ananya in Advanced Java
Ananya (S101) enrolled in Advanced Java.
Seats left in Advanced Java: 1

Student 2 details
Enter student id: S102
Enter student name: Ravi
Has the student completed Core Java? (yes/no): no
Trying to enroll Ravi in Advanced Java
Enrollment failed: Ravi must complete Core Java before enrolling in Advanced Java.
Seats left in Advanced Java: 1

Student 3 details
Enter student id: S103
Enter student name: Meera
Has the student completed Core Java? (yes/no): yes
Trying to enroll Meera in Advanced Java
Meera (S103) enrolled in Advanced Java.
Seats left in Advanced Java: 0

Student 4 details
Enter student id: S104
Enter student name: Kabir
Has the student completed Core Java? (yes/no): yes
Trying to enroll Kabir in Advanced Java
Enrollment failed: CS302 - Advanced Java is full. Maximum enrolment limit is 2.
Seats left in Advanced Java: 0