A. Given an integer NUM, determine the previous and next integers.
B. Given the values WIDTH and HEIGHT of a right triangle, calculate the area of the shape. (Area of a right triangle = 0.5 * width * height)
C. Given the cost of an order, the tip percentage, and the tax percentage, calculate the total amount to be paid.

def greetPerson(name, age):
    return f"{name} is {age} years old."

A. greetPerson("John Doe", 37)
B. greetPerson("Jane Doe", 35)

def add_by_twos():
    total = 0
    for i in range(5):
        total = total + 2
    return total

A. What does add_by_twos() return?
B. If we changed range(5) to range(3), what would the function return?
C. If we changed total + 2 to total + 3, what would the original function return?
                                

def check_steak(temp):
    if temp >= 145:
        return "Ready to eat"
    else:
        return "Keep cooking"
    
A. checkSteak(150)
B. checkSteak(140)
C. checkSteak(145)

def grade_letter(score):
    if score >= 90:
        return "A"
    elif score >= 80:
        return "B"
    elif score >= 70:
        return "C"
    elif score >= 60:
        return "D"
    else:
        return "F"

A. grade_letter(85)
B. grade_letter(92)
C. grade_letter(58)
D. grade_letter(70)

def get_student_info(students, grades):
    first_student = students[0]
    last_grade = grades[2]
    total_students = len(students)
    return f"{first_student} and there are {total_students} students"

A. What would get_student_info(['Alice', 'Bob', 'Charlie'], [85, 90, 78]) return?
B. What would get_student_info(['Emma', 'David'], [92, 88, 95]) return?
C. What would grades[1] return from the first example?
D. What would len(['x', 'y', 'z', 'w']) return?

public class BankAccount {
    private double balance;
    private String accountNumber;

    public BankAccount(String accountNumber, double initialBalance) {
        this.accountNumber = accountNumber;
        this.balance = initialBalance;
    }

    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
        }
    }

    public boolean withdraw(double amount) {
        if (amount > 0 && amount <= balance) {
            balance -= amount;
            return true;
        }
        return false;
    }

    public double getBalance() {
        return balance;
    }
}

A. Why doesn't this class have a setBalance() method?
B. What happens if you try to deposit a negative amount?
C. What does the withdraw method return if you try to withdraw more money than the balance?
D. How does this class demonstrate the principle of encapsulation?

public class Vehicle {
    protected String brand;
    protected int year;

    public Vehicle(String brand, int year) {
            this.brand = brand;
            this.year = year;
        }

    public void start() {
        System.out.println("Vehicle starting...");
    }
}

public class Car extends Vehicle {
    private int doors;
    
    public Car(String brand, int year, int doors) {
        super(brand, year);
        this.doors = doors;
    }

    @Override
    public void start() {
        System.out.println("Car engine starting...");
    }

    public void honk() {
        System.out.println("Beep beep!");
    }
}

A. What does super(brand, year) do in the Car constructor?
B. If you create: Car myCar = new Car("Toyota", 2020, 4); and call myCar.start();, what will be printed?
C. Can a Car object access the 'brand' field directly? Why or why not?
D. What's the difference between the start() method in Vehicle and Car?

public class Animal {

    public void makeSound() {
        System.out.println("Some generic animal sound");
    }
}

public class Dog extends Animal {

    @Override
    public void makeSound() {
        System.out.println("Woof!");
    }
}

public class Cat extends Animal {

    @Override
    public void makeSound() {
        System.out.println("Meow!");
    }
}

// Usage:
Animal[] animals = {new Dog(), new Cat(), new Animal()};

for (Animal animal : animals) {
    animal.makeSound();
}

A. What will be printed when the loop executes?
B. How does Java determine which makeSound() method to call for each animal?
C. What is this type of polymorphism called?"
D. Could you assign: Animal myPet = new Dog();? Why or why not?

public interface Drawable {
    void draw();
    double getArea();
}

public interface Colorable {
    void setColor(String color);
    String getColor();
}

public class Circle implements Drawable, Colorable {
    private double radius;
    private String color;


    public Circle(double radius) {
        this.radius = radius;
        this.color = "black";

    @Override
    public void draw() {
        System.out.println("Drawing a circle with radius " + radius);
    }

    @Override
    public double getArea() {
        return Math.PI * radius * radius;
    }

    @Override
    public void setColor(String color) {
        this.color = color;
    }

    @Override
    public String getColor() {
        return color;
    }
}

A. What must any class that implements Drawable provide?
B. Why can Circle implement both Drawable and Colorable interfaces?
C. What would happen if Circle didn't implement the getArea() method?
D. Can you create: Drawable shape = new Circle(5.0);?

public abstract class Shape {
    protected String name;

    public Shape(String name) {
        this.name = name;
    }

    // Abstract method - must be implemented by subclasses
    public abstract double getArea();

    // Concrete method - inherited by all subclasses
    public void printInfo() {
        System.out.println("Shape: " + name + ", Area: " + getArea());
    }
}

public class Rectangle extends Shape {
    private double width, height;

    public Rectangle(double width, double height) {
        super("Rectangle");
            this.width = width;
            this.height = height;
        }

    @Override
    public double getArea() {
        return width * height;
    }
}

A. Can you create an object like: Shape s = new Shape("test");?
B. What must the Rectangle class provide since it extends Shape?
C. Does Rectangle inherit the printInfo() method?
D. What's the main difference between an abstract class and an interface?

public class Student {
    private String name;
    private int id;

    public Student(String name, int id) {
        this.name = name;
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public int getId() {
        return id;
    }
}

public class Course {
    private String courseName;
    private List<Student> enrolledStudents;

    public Course(String courseName) {
        this.courseName = courseName;
        this.enrolledStudents = new ArrayList<>();
    }

    public void enrollStudent(Student student) {
        enrolledStudents.add(student);
    }

    public void removeStudent(Student student) {
        enrolledStudents.remove(student);
    }

    public int getEnrollmentCount() {
        return enrolledStudents.size();
    }
}


A. What type of relationship exists between Course and Student?
B. If a Course object is destroyed, what happens to the Student objects?
C. Can a Student be enrolled in multiple courses?
D. What does the enrollStudent() method demonstrate about aggregation?

public class Author {
    private String name;
    private List<<Book> booksWritten

    public Author(String name) {
        this.name = name;
        this.booksWritten = new ArrayList<>();
    }

    public void addBook(Book book) {
        booksWritten.add(book);
        book.setAuthor(this);
    }

    public String getName() {
        return name;
    }
}

public class Book {
    private String title;
    private Author author;

    public Book(String title) {
        this.title = title;
    }

    public void setAuthor(Author author) {
        this.author = author;
    }

    public Author getAuthor() {
        return author;
    }

    public String getTitle() {
        return title;
    }
}

// Usage:
    Author author = new Author("J.K. Rowling");
    Book book = new Book("Harry Potter");
    author.addBook(book);

A. What type of association exists between Author and Book?
B. How many authors can a book have in this design?
C. What happens when author.addBook(book) is called?
D. Is this association unidirectional or bidirectional?

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

public class BankingService {
    public void transferMoney(BankAccount from, BankAccount to, double amount) throws InsufficientFundsException {
        try {
            if (from.getBalance() < amount) {
                throw new InsufficientFundsException(
                    "Insufficient funds. Available: " + from.getBalance());
            }
            from.withdraw(amount);
            to.deposit(amount);
            System.out.println("Transfer successful");
        } catch (IllegalArgumentException e) {
            System.err.println("Invalid transfer amount: " + e.getMessage());
            throw e;
        } finally {
            System.out.println("Transfer operation completed");
        }
    }

    public static void main(String[] args) {
        BankAccount acc1 = new BankAccount("123", 100.0);
        BankAccount acc2 = new BankAccount("456", 50.0);
        BankingService service = new BankingService();

        try {
            service.transferMoney(acc1, acc2, 150.0);
        } catch (InsufficientFundsException e) {
            System.err.println("Transfer failed: " + e.getMessage());
        }
    }
}

A. What type of exception is InsufficientFundsException and why does the transferMoney method need throws in its signature?
B. What will be printed when the main method tries to transfer $150 from an account with $100?
C. When does the finally block execute?
D. What's the difference between throwing an InsufficientFundsException and an IllegalArgumentException in this code?

public class DataContainer <T extends Comparable> {
    private List<T> items;

    public DataContainer() {
        this.items = new ArrayList<T>();
            }

    public void addItem(T item) {
        items.add(item);
    }

    public T getItem(int index) {
        if (index >= 0 && index < items.size()) {
            return items.get(index);
        }
        return null;
    }

    public T findMax() {
        if (items.isEmpty())
            return null;

        T max = items.get(0);

        for (T item : items) {
            if (item.compareTo(max) > 0) {
                max = item;
            }
        }

        return max;
    }

    public int getSize() {
        return items.size();
    }
}

// Usage:
    DataContainer<String> stringContainer = new DataContainer<>();
    stringContainer.addItem("Hello");
    String result = stringContainer.getItem(0);

    DataContainer<Integer> intContainer = new DataContainer<>();
    intContainer.addItem(42);

A. What does the <T> in the class declaration mean and what advantage does it provide?
B. What does <T extends Comparable> mean in the DataContainer class declaration?
C. Why doesn't stringContainer.getItem(0) require casting to String?
D. What would happen if you tried: stringContainer.addItem(123)?