public class HelloWorld {
    // The program entry point, the main method
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}
    Copy
  

    # 1. Compile the source file
javac HelloWorld.java

# 2. Run the bytecode
java HelloWorld
    Copy
  

    public class Types {
    public static void main(String[] args) {
        int age = 20;
        double price = 19.99;
        char grade = 'A';
        boolean isStudent = true;
        long population = 7900000000L;
        float pi = 3.14f;

        System.out.println("Age: " + age);
        System.out.println("Price: " + price);
        System.out.println("Grade: " + grade);
        System.out.println("Is student: " + isStudent);
    }
}
    Copy
  

    public class Cast {
    public static void main(String[] args) {
        // automatic conversion: int → double
        int i = 100;
        double d = i;
        System.out.println("Automatic: " + d);

        // explicit cast: double → int
        double pi = 3.99;
        int n = (int) pi;  // truncates the fractional part
        System.out.println("Explicit: " + n);
    }
}
    Copy
  

    public class StringDemo {
    public static void main(String[] args) {
        String name = "Alice";
        String greeting = "Hello";
        // string concatenation uses +
        System.out.println(greeting + ", " + name + "!");

        // common methods
        System.out.println("Length: " + name.length());
        System.out.println("Uppercase: " + "hello".toUpperCase());
        System.out.println("Concat: " + "a".concat("b"));
    }
}
    Copy
  

    public class Arithmetic {
    public static void main(String[] args) {
        int a = 17, b = 5;
        System.out.println("Add: " + (a + b));    // 22
        System.out.println("Sub: " + (a - b));    // 12
        System.out.println("Mul: " + (a * b));    // 85
        System.out.println("Div: " + (a / b));    // 3 (integer division, truncated)
        System.out.println("Mod: " + (a % b));    // 2
    }
}
    Copy
  

    public class IncDec {
    public static void main(String[] args) {
        int i = 5;
        System.out.println(i++);  // 5 (uses, then +1)
        System.out.println(i);    // 6
        System.out.println(++i);  // 7 (+1, then uses)
    }
}
    Copy
  

    public class Logic {
    public static void main(String[] args) {
        int score = 75;
        // logical AND
        boolean pass = score >= 60 && score <= 100;
        System.out.println("Pass: " + pass);

        // logical OR
        boolean holiday = false;
        boolean weekend = true;
        boolean canRest = holiday || weekend;
        System.out.println("Can rest: " + canRest);

        // short-circuit behavior
        int x = 0;
        if (x != 0 && 10 / x > 1) {
            System.out.println("this line never runs");
        }
        System.out.println("Short-circuit avoided division by zero");
    }
}
    Copy
  

    public class Assign {
    public static void main(String[] args) {
        int n = 10;
        n += 5;  // equivalent to n = n + 5
        System.out.println("After +=: " + n);  // 15

        // ternary: condition ? trueValue : falseValue
        int age = 17;
        String status = age >= 18 ? "Adult" : "Underage";
        System.out.println(status);
    }
}
    Copy
  

    public class IfElse {
    public static void main(String[] args) {
        int score = 85;

        if (score >= 90) {
            System.out.println("Excellent");
        } else if (score >= 80) {
            System.out.println("Good");
        } else if (score >= 60) {
            System.out.println("Pass");
        } else {
            System.out.println("Fail");
        }
    }
}
    Copy
  

    public class Nested {
    public static void main(String[] args) {
        int age = 20;
        boolean hasLicense = true;

        if (age >= 18) {
            if (hasLicense) {
                System.out.println("Can drive");
            } else {
                System.out.println("Adult, but no license");
            }
        } else {
            System.out.println("Underage, cannot drive");
        }
    }
}
    Copy
  

    public class Switch {
    public static void main(String[] args) {
        int day = 3;
        switch (day) {
            case 1:
                System.out.println("Monday");
                break;
            case 2:
                System.out.println("Tuesday");
                break;
            case 3:
                System.out.println("Wednesday");
                break;
            default:
                System.out.println("Other");
        }
    }
}
    Copy
  

    public class SwitchNew {
    public static void main(String[] args) {
        int day = 3;
        String name = switch (day) {
            case 1 -> "Monday";
            case 2 -> "Tuesday";
            case 3 -> "Wednesday";
            default -> "Other";
        };
        System.out.println(name);
    }
}
    Copy
  

    public class ForLoop {
    public static void main(String[] args) {
        // print 1 to 5
        for (int i = 1; i <= 5; i++) {
            System.out.println("Iteration " + i);
        }
    }
}
    Copy
  

    public class WhileLoop {
    public static void main(String[] args) {
        int n = 1024;
        int count = 0;
        // keep dividing by 2 until n becomes 0
        while (n > 0) {
            n = n / 2;
            count++;
        }
        System.out.println("Looped " + count + " times");
    }
}
    Copy
  

    public class DoWhile {
    public static void main(String[] args) {
        int i = 10;
        do {
            System.out.println("i = " + i);
            i++;
        } while (i < 5);  // condition is false, but the body ran once
    }
}
    Copy
  

    public class BreakContinue {
    public static void main(String[] args) {
        // break: exit the whole loop
        System.out.println("=== break example ===");
        for (int i = 1; i <= 10; i++) {
            if (i == 5) break;  // stop at 5
            System.out.println(i);
        }

        // continue: skip this iteration, move to the next
        System.out.println("=== continue example ===");
        for (int i = 1; i <= 10; i++) {
            if (i % 2 == 0) continue;  // skip even numbers
            System.out.println(i);
        }
    }
}
    Copy
  

    public class Multiplication {
    public static void main(String[] args) {
        for (int i = 1; i <= 9; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.printf("%d×%d=%-4d", j, i, i * j);
            }
            System.out.println();
        }
    }
}
    Copy
  

    public class MethodBasic {
    // method definition: modifier returnType methodName(parameters)
    public static int add(int a, int b) {
        return a + b;
    }

    // void for no return value
    public static void greet(String name) {
        System.out.println("Hello, " + name + "!");
    }

    public static void main(String[] args) {
        int result = add(3, 5);    // call a method with a return value
        System.out.println("3 + 5 = " + result);

        greet("Alice");            // call a method with no return value
    }
}
    Copy
  

    public class Overload {
    // two ints added
    public static int add(int a, int b) {
        return a + b;
    }
    // three ints added
    public static int add(int a, int b, int c) {
        return a + b + c;
    }
    // two doubles added
    public static double add(double a, double b) {
        return a + b;
    }

    public static void main(String[] args) {
        System.out.println(add(1, 2));        // calls the first
        System.out.println(add(1, 2, 3));     // calls the second
        System.out.println(add(1.5, 2.5));    // calls the third
    }
}
    Copy
  

    public class PassByValue {
    public static void change(int x) {
        x = 100;  // only changes the copy
    }

    public static void main(String[] args) {
        int n = 10;
        change(n);
        System.out.println("n = " + n);  // still 10
    }
}
    Copy
  

    public class Scope {
    public static void main(String[] args) {
        int x = 10;  // main method scope
        if (x > 5) {
            int y = 20;  // if-block scope
            System.out.println(x + y);  // 30
        }
        // System.out.println(y);  // compile error! y is not visible here
    }
}
    Copy
  

    public class Recursion {
    // n! = n * (n-1)!
    public static int factorial(int n) {
        if (n <= 1) return 1;        // base case
        return n * factorial(n - 1); // recursive call
    }

    public static void main(String[] args) {
        System.out.println("5! = " + factorial(5));  // 120
    }
}
    Copy
  

    public class ArrayBasic {
    public static void main(String[] args) {
        // declare and initialize
        int[] scores = {90, 85, 78, 92, 88};

        // access elements (index starts at 0)
        System.out.println("First: " + scores[0]);
        System.out.println("Third: " + scores[2]);

        // array length
        System.out.println("Length: " + scores.length);

        // modify an element
        scores[1] = 95;
        System.out.println("After change: " + scores[1]);
    }
}
    Copy
  

    public class ArrayCreate {
    public static void main(String[] args) {
        // way 1: declare, then allocate space
        int[] a = new int[5];  // all default to 0
        a[0] = 10;

        // way 2: direct initialization
        int[] b = {1, 2, 3};

        // way 3: new + initialization
        String[] names = new String[]{"Alice", "Bob", "Carol"};

        System.out.println(a[0] + " " + a[1]);  // 10 0
        System.out.println(names.length);
    }
}
    Copy
  

    public class ArrayLoop {
    public static void main(String[] args) {
        int[] nums = {10, 20, 30, 40, 50};

        // way 1: a normal for loop
        System.out.print("for: ");
        for (int i = 0; i < nums.length; i++) {
            System.out.print(nums[i] + " ");
        }
        System.out.println();

        // way 2: the enhanced for (for-each)
        System.out.print("for-each: ");
        for (int num : nums) {
            System.out.print(num + " ");
        }
        System.out.println();
    }
}
    Copy
  

    public class ArrayMax {
    public static void main(String[] args) {
        int[] nums = {3, 7, 2, 9, 5, 1, 8};
        int max = nums[0];  // assume the first is the largest

        for (int i = 1; i < nums.length; i++) {
            if (nums[i] > max) {
                max = nums[i];
            }
        }
        System.out.println("Max: " + max);
    }
}
    Copy
  

    public class TwoD {
    public static void main(String[] args) {
        int[][] matrix = {
            {1, 2, 3},
            {4, 5, 6},
            {7, 8, 9}
        };

        // iterate the 2D array
        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix[i].length; j++) {
                System.out.print(matrix[i][j] + " ");
            }
            System.out.println();
        }
    }
}
    Copy
  

    // Student class
public class Student {
    // attributes (fields / member variables)
    String name;
    int age;
    double score;

    // methods (behavior)
    public void study() {
        System.out.println(name + " is studying");
    }

    public void introduce() {
        System.out.println("I am " + name + ", " + age + " years old");
    }
}
    Copy
  

    public class Main {
    public static void main(String[] args) {
        // create an object
        Student s1 = new Student();
        s1.name = "Alice";
        s1.age = 20;
        s1.score = 92.5;

        // call methods
        s1.introduce();
        s1.study();

        // create another object
        Student s2 = new Student();
        s2.name = "Bob";
        s2.age = 21;
        s2.introduce();
    }
}
    Copy
  

    public class Book {
    String title;
    double price;

    public void setInfo(String title, double price) {
        this.title = title;    // this.title is the member variable
        this.price = price;    // the right-side title is the parameter
    }

    public void show() {
        System.out.println(title + " price: " + price);
    }

    public static void main(String[] args) {
        Book b = new Book();
        b.setInfo("Java Basics", 59.9);
        b.show();
    }
}
    Copy
  

    public class MathUtil {
    // static variable: shared by all objects
    static int count = 0;

    // static method: called directly with the class name
    public static int square(int n) {
        return n * n;
    }

    public MathUtil() {
        count++;  // each object created increments count
    }

    public static void main(String[] args) {
        System.out.println("Square of 3: " + MathUtil.square(3));

        new MathUtil();
        new MathUtil();
        System.out.println("Created " + MathUtil.count + " objects");
    }
}
    Copy
  

    public class Account {
    private String owner;
    private double balance;

    // getter
    public double getBalance() {
        return balance;
    }

    // setter: adds validation logic
    public void setBalance(double balance) {
        if (balance < 0) {
            System.out.println("Balance cannot be negative!");
            return;
        }
        this.balance = balance;
    }

    public String getOwner() {
        return owner;
    }

    public void setOwner(String owner) {
        this.owner = owner;
    }
}
    Copy
  

    public class AccountTest {
    public static void main(String[] args) {
        Account acc = new Account();
        acc.setOwner("Alice");
        acc.setBalance(1000);
        System.out.println(acc.getOwner() + " balance: " + acc.getBalance());

        acc.setBalance(-500);  // will be rejected
        System.out.println(acc.getOwner() + " balance: " + acc.getBalance());
    }
}
    Copy
  

    public class Person {
    private String name;
    private int age;

    // no-arg constructor
    public Person() {
        this.name = "Unknown";
        this.age = 0;
    }

    // parameterized constructor (overload)
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void show() {
        System.out.println(name + ", " + age + " years old");
    }

    public static void main(String[] args) {
        Person p1 = new Person();           // uses the no-arg constructor
        Person p2 = new Person("Bob", 25);  // uses the parameterized one
        p1.show();
        p2.show();
    }
}
    Copy
  

    public class Car {
    String brand;
    String color;
    int year;

    public Car(String brand) {
        this(brand, "White", 2024);  // calls the three-arg constructor
    }

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

    public void info() {
        System.out.println(year + " " + color + " " + brand);
    }

    public static void main(String[] args) {
        Car c = new Car("Toyota");
        c.info();
    }
}
    Copy
  

    public class Product {
    private int id;
    private String name;
    private double price;

    // no-arg constructor (required)
    public Product() {}

    // all-args constructor (recommended)
    public Product(int id, String name, double price) {
        this.id = id;
        this.name = name;
        this.price = price;
    }

    public int getId() { return id; }
    public void setId(int id) { this.id = id; }
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public double getPrice() { return price; }
    public void setPrice(double price) { this.price = price; }
}
    Copy
  

    // parent class (base class)
class Animal {
    String name;

    public void eat() {
        System.out.println(name + " is eating");
    }

    public void sleep() {
        System.out.println(name + " is sleeping");
    }
}

// subclass inheriting Animal
class Dog extends Animal {
    public void bark() {
        System.out.println(name + " barks!");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog d = new Dog();
        d.name = "Buddy";
        d.eat();    // inherited from the parent
        d.bark();   // the subclass's own method
    }
}
    Copy
  

    class Shape {
    public double area() {
        return 0;
    }
}

class Circle extends Shape {
    double radius;
    public Circle(double r) { this.radius = r; }

    @Override  // override annotation; helps the compiler check
    public double area() {
        return Math.PI * radius * radius;
    }
}

class Rectangle extends Shape {
    double width, height;
    public Rectangle(double w, double h) {
        this.width = w;
        this.height = h;
    }

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

public class Main {
    public static void main(String[] args) {
        Circle c = new Circle(5);
        Rectangle r = new Rectangle(4, 6);
        System.out.printf("Circle area: %.2f%n", c.area());
        System.out.printf("Rect area: %.2f%n", r.area());
    }
}
    Copy
  

    class Vehicle {
    String brand;
    public Vehicle(String brand) {
        this.brand = brand;
        System.out.println("Vehicle constructed");
    }
    public void run() {
        System.out.println(brand + " is driving");
    }
}

class Car extends Vehicle {
    int wheels;
    public Car(String brand, int wheels) {
        super(brand);      // calls the parent constructor; must be the first line
        this.wheels = wheels;
        System.out.println("Car constructed");
    }

    @Override
    public void run() {
        super.run();       // calls the parent method
        System.out.println(brand + " has " + wheels + " wheels");
    }
}

public class Main {
    public static void main(String[] args) {
        Car car = new Car("Mercedes", 4);
        car.run();
    }
}
    Copy
  

    class Animal {
    public void speak() {
        System.out.println("Animal sound");
    }
}
class Dog extends Animal {
    public void speak() { System.out.println("Woof!"); }
}
class Cat extends Animal {
    public void speak() { System.out.println("Meow!"); }
}

public class Main {
    // a parent reference as a parameter — the power of polymorphism
    public static void makeSpeak(Animal a) {
        a.speak();  // the runtime decides which subclass method runs
    }

    public static void main(String[] args) {
        // parent reference pointing to subclass objects
        Animal a1 = new Dog();  // upcasting
        Animal a2 = new Cat();

        makeSpeak(a1);  // Woof!
        makeSpeak(a2);  // Meow!
    }
}
    Copy
  

    Animal a = new Dog();  // upcasting
// a.bark();  // compile error! Animal has no bark method

if (a instanceof Dog) {
    Dog d = (Dog) a;  // downcasting
    d.bark();         // now Dog-specific methods can be called
}
    Copy
  

    if (a instanceof Dog d) {
    d.bark();  // d is automatically declared and cast
}
    Copy
  

    abstract class Shape {
    // abstract method: declaration only, no implementation
    public abstract double area();

    // a concrete method: allowed in an abstract class
    public void display() {
        System.out.printf("Area = %.2f%n", area());
    }
}

class Triangle extends Shape {
    double base, height;
    public Triangle(double b, double h) {
        this.base = b; this.height = h;
    }
    @Override
    public double area() {
        return 0.5 * base * height;
    }
}

public class Main {
    public static void main(String[] args) {
        Shape s = new Triangle(3, 4);
        s.display();
    }
}
    Copy
  

    // define an interface
interface Flyable {
    void fly();  // public abstract by default
}

interface Swimmable {
    void swim();
}

// implement multiple interfaces
class Duck implements Flyable, Swimmable {
    public void fly() {
        System.out.println("Duck flies");
    }
    public void swim() {
        System.out.println("Duck swims");
    }
}

public class Main {
    public static void main(String[] args) {
        Duck d = new Duck();
        d.fly();
        d.swim();

        // interface references can also be polymorphic
        Flyable f = new Duck();
        f.fly();
    }
}
    Copy
  

    public class TryCatch {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3};
        try {
            System.out.println(arr[5]);  // out of bounds!
            System.out.println("this line never runs");
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("Caught exception: " + e.getMessage());
        } finally {
            System.out.println("Finally always runs");
        }
        System.out.println("Program continues");
    }
}
    Copy
  

    try {
    String s = null;
    System.out.println(s.length());  // a null pointer
} catch (NullPointerException e) {
    System.out.println("NullPointerException");
} catch (Exception e) {       // parent exceptions go last
    System.out.println("Other exception");
}
    Copy
  

    public class ThrowsDemo {
    // throws declares the exceptions a method may throw
    public static int divide(int a, int b) throws ArithmeticException {
        if (b == 0) {
            // throw actively throws an exception
            throw new ArithmeticException("divisor cannot be zero");
        }
        return a / b;
    }

    public static void main(String[] args) {
        try {
            System.out.println(divide(10, 0));
        } catch (ArithmeticException e) {
            System.out.println("Error: " + e.getMessage());
        }
    }
}
    Copy
  

    // inherit Exception to create a checked exception
class AgeInvalidException extends Exception {
    public AgeInvalidException(String msg) {
        super(msg);
    }
}

public class CustomException {
    public static void checkAge(int age) throws AgeInvalidException {
        if (age < 0 || age > 150) {
            throw new AgeInvalidException("Invalid age: " + age);
        }
        System.out.println("Valid age: " + age);
    }

    public static void main(String[] args) {
        try {
            checkAge(200);
        } catch (AgeInvalidException e) {
            System.out.println("Caught: " + e.getMessage());
        }
    }
}
    Copy
  

    import java.util.ArrayList;
import java.util.List;

public class ArrayListDemo {
    public static void main(String[] args) {
        // create an ArrayList (generics specify the element type)
        List<String> fruits = new ArrayList<>();

        // add elements
        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add("Orange");

        // get an element
        System.out.println("Second: " + fruits.get(1));

        // modify an element
        fruits.set(0, "Fuji");

        // iterate
        for (String f : fruits) {
            System.out.println(f);
        }

        // remove
        fruits.remove("Orange");
        System.out.println("Size after remove: " + fruits.size());
        System.out.println("Contains Banana? " + fruits.contains("Banana"));
    }
}
    Copy
  

    import java.util.HashMap;
import java.util.Map;

public class HashMapDemo {
    public static void main(String[] args) {
        // create a HashMap
        Map<String, Integer> scores = new HashMap<>();

        // add key-value pairs
        scores.put("Zhang San", 90);
        scores.put("Li Si", 85);
        scores.put("Wang Wu", 95);

        // get a value by key
        System.out.println("Li Si score: " + scores.get("Li Si"));

        // modify: putting the same key overwrites
        scores.put("Zhang San", 88);
        System.out.println("Zhang San new score: " + scores.get("Zhang San"));

        // iterate
        for (Map.Entry<String, Integer> entry : scores.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }

        // check whether a key exists
        System.out.println("Has Wang Wu? " + scores.containsKey("Wang Wu"));
        System.out.println("Size: " + scores.size());
    }
}
    Copy
  

    import java.util.HashSet;
import java.util.Set;

public class HashSetDemo {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>();
        set.add("Java");
        set.add("Python");
        set.add("Java");  // duplicate; will not be added
        set.add("C++");

        System.out.println("Size: " + set.size());  // 3
        for (String s : set) {
            System.out.println(s);
        }

        // remove
        set.remove("C++");
        System.out.println("Has C++ after remove? " + set.contains("C++"));
    }
}
    Copy
  

    import java.util.HashMap;
import java.util.Map;

public class WordCount {
    public static void main(String[] args) {
        String[] words = {"java", "python", "java", "c++", "python", "java"};

        Map<String, Integer> count = new HashMap<>();
        for (String w : words) {
            // getOrDefault: returns a default when the key is absent
            count.put(w, count.getOrDefault(w, 0) + 1);
        }

        for (Map.Entry<String, Integer> e : count.entrySet()) {
            System.out.println(e.getKey() + " appears " + e.getValue() + " times");
        }
    }
}
    Copy
  

    import java.util.ArrayList;
import java.util.List;

public class NoGeneric {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("hello");
        list.add(123);       // can mix different types!

        String s = (String) list.get(1);  // runtime ClassCastException
        System.out.println(s);
    }
}
    Copy
  

    import java.util.ArrayList;
import java.util.List;

public class Generic {
    public static void main(String[] args) {
        // the collection can only store String
        List<String> list = new ArrayList<>();
        list.add("hello");
        // list.add(123);  // compile error! blocked at compile time

        String s = list.get(0);  // no cast needed
        System.out.println(s);
    }
}
    Copy
  

    // a generic class: T is the type parameter
public class Box<T> {
    private T item;

    public void put(T item) {
        this.item = item;
    }

    public T get() {
        return item;
    }

    public static void main(String[] args) {
        Box<String> strBox = new Box<>();
        strBox.put("gift");
        System.out.println(strBox.get());

        Box<Integer> intBox = new Box<>();
        intBox.put(42);
        System.out.println(intBox.get());
    }
}
    Copy
  

    public class GenericMethod {
    // a generic method: <T> declares the type parameter
    public static <T> void printArray(T[] arr) {
        for (T item : arr) {
            System.out.print(item + " ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        Integer[] nums = {1, 2, 3};
        String[] strs = {"A", "B", "C"};

        printArray(nums);  // infers T = Integer
        printArray(strs);  // infers T = String
    }
}
    Copy
  

    import java.util.ArrayList;
import java.util.List;

// Student class (encapsulation)
class Student {
    private int id;
    private String name;
    private double score;

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

    public int getId() { return id; }
    public String getName() { return name; }
    public double getScore() { return score; }

    public String toString() {
        return String.format("ID:%d  Name:%s  Score:%.1f", id, name, score);
    }
}

// Student management system
class StudentManager {
    private List<Student> students = new ArrayList<>();

    // add a student
    public void add(Student s) {
        students.add(s);
        System.out.println("Added: " + s.getName());
    }

    // delete by id
    public void removeById(int id) {
        students.removeIf(s -> s.getId() == id);
        System.out.println("Deleted ID " + id);
    }

    // list all
    public void listAll() {
        if (students.isEmpty()) {
            System.out.println("No students yet");
            return;
        }
        for (Student s : students) {
            System.out.println(s);
        }
    }

    // compute the average score
    public double average() {
        if (students.isEmpty()) return 0;
        double sum = 0;
        for (Student s : students) sum += s.getScore();
        return sum / students.size();
    }
}

public class StudentSystem {
    public static void main(String[] args) {
        StudentManager mgr = new StudentManager();

        mgr.add(new Student(1, "Alice", 90));
        mgr.add(new Student(2, "Bob", 85));
        mgr.add(new Student(3, "Carol", 78));

        System.out.println("\n--- All students ---");
        mgr.listAll();

        System.out.println("\n--- Delete Bob ---");
        mgr.removeById(2);

        System.out.println("\n--- After deletion ---");
        mgr.listAll();

        System.out.printf("%nAverage: %.1f%n", mgr.average());
    }
}
    Copy