Week 5: Lab — Thinking in Objects

1Encapsulated & Immutable Student

Think about it: A university system stores student records. Once a student ID and name are registered, they should never change — that's immutability. But the GPA can be updated through a controlled setter with validation (0.0–4.0 only). This combines encapsulation (private fields, getters/setters) with immutability (no setter for id/name).

Create an ImmutableStudent class with private fields: id (int), name (String), and gpa (double). Provide getters for all fields, but a setter only for gpa with validation (0.0 to 4.0). The id and name are set only through the constructor and can never be changed. In main, create a student, try to update gpa with valid and invalid values.

Expected OutputID: 1001, Name: Ali, GPA: 3.5 Setting GPA to 5.0 (invalid)... ID: 1001, Name: Ali, GPA: 3.5 Setting GPA to 3.9 (valid)... ID: 1001, Name: Ali, GPA: 3.9

Your Code

class ImmutableStudent {
    // Private fields: id (int), name (String), gpa (double)


    // Constructor that takes id, name, gpa


    // Getter for id (NO setter — immutable)


    // Getter for name (NO setter — immutable)


    // Getter for gpa


    // Setter for gpa WITH validation (0.0 to 4.0 only)

}

public class TestImmutableStudent {
    public static void main(String[] args) {
        ImmutableStudent s = new ImmutableStudent(1001, "Ali", 3.5);
        System.out.println("ID: " + s.getId() + ", Name: " + s.getName() + ", GPA: " + s.getGpa());

        System.out.println("Setting GPA to 5.0 (invalid)...");
        s.setGpa(5.0);
        System.out.println("ID: " + s.getId() + ", Name: " + s.getName() + ", GPA: " + s.getGpa());

        System.out.println("Setting GPA to 3.9 (valid)...");
        s.setGpa(3.9);
        System.out.println("ID: " + s.getId() + ", Name: " + s.getName() + ", GPA: " + s.getGpa());
    }
}

Declare: private int id; private String name; private double gpa;. Constructor: ImmutableStudent(int id, String name, double gpa) { this.id = id; this.name = name; this.gpa = gpa; }. Only provide getters for id and name (no setters!). Setter for gpa: public void setGpa(double gpa) { if (gpa >= 0.0 && gpa <= 4.0) this.gpa = gpa; }.

2Variable Scope Explorer

Think about it: Understanding scope prevents bugs caused by variable shadowing. When a local variable has the same name as an instance variable, the local one takes priority. Using this lets you explicitly access the instance variable. This exercise makes you practice distinguishing between local and instance scope.

Create a ScopeTest class with an instance variable x = 10. Add a method demonstrate(int x) that receives a parameter named x (same name!). Inside the method, print: (1) the local parameter x, (2) the instance variable using this.x, (3) create a local variable y and print it. Then call the method from main with argument 50.

Expected OutputParameter x: 50 Instance x: 10 Local y: 99 Back in main — cannot access y here

Your Code

class ScopeTest {
    // Instance variable x = 10


    // Method: demonstrate(int x)
    // Print parameter x, this.x, and a local variable y = 99

}

public class TestScope {
    public static void main(String[] args) {
        ScopeTest obj = new ScopeTest();
        obj.demonstrate(50);
        System.out.println("Back in main — cannot access y here");
    }
}

Instance variable: int x = 10;. Method:

public void demonstrate(int x) { System.out.println("Parameter x: " + x); System.out.println("Instance x: " + this.x); int y = 99; System.out.println("Local y: " + y); }

. The parameter x shadows the instance variable, so use this.x to access the instance one.

3Static Counter & Constant

Think about it: A pizza shop wants to track how many pizzas have been ordered and apply a fixed tax rate to every order. The order count should be shared across all Pizza objects (static variable), and the tax rate should be a constant that nobody can change (static final). This exercise practices static variables, static constants, and static methods.

Create a Pizza class with: instance fields name (String) and price (double), a static variable orderCount = 0, and a static final constant TAX_RATE = 0.16. The constructor increments orderCount. Add a method getTotalPrice() that returns price + price * TAX_RATE. Add a static method getOrderCount(). Create 3 pizzas in main.

Expected OutputMargherita total: 11.6 Pepperoni total: 16.24 Hawaiian total: 13.92 Total orders: 3

Your Code

class Pizza {
    // Instance fields: name (String), price (double)


    // Static variable: orderCount = 0


    // Static constant: TAX_RATE = 0.16


    // Constructor: takes name and price, increments orderCount


    // Method: getTotalPrice() — returns price + price * TAX_RATE


    // Static method: getOrderCount()

}

public class TestPizza {
    public static void main(String[] args) {
        Pizza p1 = new Pizza("Margherita", 10.0);
        Pizza p2 = new Pizza("Pepperoni", 14.0);
        Pizza p3 = new Pizza("Hawaiian", 12.0);

        System.out.println(p1.name + " total: " + p1.getTotalPrice());
        System.out.println(p2.name + " total: " + p2.getTotalPrice());
        System.out.println(p3.name + " total: " + p3.getTotalPrice());
        System.out.println("Total orders: " + Pizza.getOrderCount());
    }
}

Fields: String name; double price; static int orderCount = 0; public static final double TAX_RATE = 0.16;. Constructor: Pizza(String name, double price) { this.name = name; this.price = price; orderCount++; }. Method: public double getTotalPrice() { return price + price * TAX_RATE; }. Static: public static int getOrderCount() { return orderCount; }.

4Passing Objects — Circle Resizer

Think about it: When you pass a primitive to a method, it gets a copy — changes don't affect the original. But when you pass an object, the method receives a copy of the reference — so it can modify the original object's fields! This is a fundamental concept to understand in Java.

Create a Circle class with a private field radius, a constructor, getter, and setter. Write two static methods in the test class: doubleValue(int n) that doubles a primitive (won't affect the original), and doubleRadius(Circle c) that doubles a circle's radius (WILL affect the original). Demonstrate both in main.

Expected OutputBefore: num = 5 After doubleValue: num = 5 Before: radius = 10.0 After doubleRadius: radius = 20.0

Your Code

class Circle {
    private double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

    public double getRadius() { return radius; }
    public void setRadius(double radius) { this.radius = radius; }
}

public class TestPassing {
    // Static method: doubleValue(int n) — doubles n (only local copy)


    // Static method: doubleRadius(Circle c) — doubles c's radius using setRadius


    public static void main(String[] args) {
        // Test primitive passing
        int num = 5;
        System.out.println("Before: num = " + num);
        doubleValue(num);
        System.out.println("After doubleValue: num = " + num);

        // Test object passing
        Circle c = new Circle(10.0);
        System.out.println("Before: radius = " + c.getRadius());
        doubleRadius(c);
        System.out.println("After doubleRadius: radius = " + c.getRadius());
    }
}

Primitive method: public static void doubleValue(int n) { n = n * 2; } — this only changes the local copy. Object method: public static void doubleRadius(Circle c) { c.setRadius(c.getRadius() * 2); } — this modifies the actual object because c is a reference to the same object.

5Array of Objects — Student Roster

Think about it: A professor needs to manage a roster of students. Using an array of objects, you can store multiple Student objects and loop through them to find the highest GPA, calculate the average, or print all students. Remember: creating the array doesn't create the objects — you must new each one!

Create a Student class with fields name (String) and gpa (double). Create an array of 4 students. Loop through the array to: (1) print each student, (2) find the student with the highest GPA, (3) calculate the average GPA.

Expected Output--- Roster --- Ali: 3.5 Sara: 3.9 Omar: 3.2 Lina: 3.7 Best student: Sara (GPA: 3.9) Average GPA: 3.575

Your Code

class Student {
    String name;
    double gpa;

    // Constructor

}

public class TestRoster {
    public static void main(String[] args) {
        // Create array of 4 students
        // Student("Ali", 3.5), Student("Sara", 3.9)
        // Student("Omar", 3.2), Student("Lina", 3.7)


        // Print all students
        System.out.println("--- Roster ---");
        // Use a for-each loop


        // Find the student with the highest GPA
        Student best = students[0];
        // Loop and compare


        System.out.println("Best student: " + best.name + " (GPA: " + best.gpa + ")");

        // Calculate average GPA
        double sum = 0;
        // Loop and sum


        System.out.println("Average GPA: " + (sum / students.length));
    }
}

Constructor: Student(String name, double gpa) { this.name = name; this.gpa = gpa; }. Array:

Student[] students = { new Student("Ali", 3.5), new Student("Sara", 3.9), new Student("Omar", 3.2), new Student("Lina", 3.7) };

. Print: for (Student s : students) System.out.println(s.name + ": " + s.gpa);. Best: for (Student s : students) if (s.gpa > best.gpa) best = s;. Average: for (Student s : students) sum += s.gpa;.

6Aggregation vs. Composition — School System

Think about it: A School has an Address that is created when the school is built — that's composition (created inside). A School also has a Principal who was hired from outside — that's aggregation (passed in). This exercise asks you to implement both in one class.

Create an Address class with a field city. Create a Principal class with a field name. Create a School class that uses composition for Address (created inside the constructor with new Address(city)) and aggregation for Principal (passed in as a parameter). Add a display() method. Show that the Principal exists independently after the school is gone.

Expected OutputSchool: Petra School, City: Amman, Principal: Dr. Ahmad Principal still exists: Dr. Ahmad

Your Code

class Address {
    String city;
    // Constructor

}

class Principal {
    String name;
    // Constructor

}

class School {
    String name;
    Address address;      // Composition — created inside
    Principal principal;  // Aggregation — passed in

    // Constructor: takes name, city (String), and Principal (object)
    // Create Address INSIDE with new Address(city)
    // Assign Principal from parameter


    // display() — print school name, city, and principal name

}

public class TestSchool {
    public static void main(String[] args) {
        // Create Principal outside
        Principal p = new Principal("Dr. Ahmad");

        // Create School — Address created inside, Principal passed in
        School s = new School("Petra School", "Amman", p);
        s.display();

        // Set school to null
        s = null;

        // Principal still exists!
        System.out.println("Principal still exists: " + p.name);
    }
}

Address: Address(String city) { this.city = city; }. Principal: Principal(String name) { this.name = name; }. School constructor:

School(String name, String city, Principal principal) { this.name = name; this.address = new Address(city); this.principal = principal; }

. Key: new Address(city) = composition (inside), this.principal = principal = aggregation (passed in).

7String Processing — Password Validator

Think about it: A registration form needs to validate passwords. Using String methods, you can check length, whether it contains certain characters, and compare values. This exercise practices length(), contains(), charAt(), equals(), and toUpperCase().

Write a program that validates a password string. Check: (1) length is at least 8 using length(), (2) contains "A" or "a" using contains(), (3) first character is uppercase using charAt(0) and Character.isUpperCase(). Also demonstrate == vs .equals() with two identical strings created differently.

Expected OutputPassword: HelloJava123 Length OK (>= 8): true Contains 'a': true Starts with uppercase: true --- String Comparison --- s1 == s2 (literals): true s1 == s3 (new String): false s1.equals(s3): true

Your Code

public class PasswordValidator {
    public static void main(String[] args) {
        String password = "HelloJava123";
        System.out.println("Password: " + password);

        // Check length >= 8 using length()


        // Check contains "a" using contains()


        // Check first char is uppercase using charAt(0) and Character.isUpperCase()


        // String comparison demo
        System.out.println("--- String Comparison ---");
        String s1 = "Java";
        String s2 = "Java";
        String s3 = new String("Java");

        // Print s1 == s2, s1 == s3, s1.equals(s3)

    }
}

Length: System.out.println("Length OK (>= 8): " + (password.length() >= 8));. Contains: System.out.println("Contains 'a': " + password.contains("a"));. Uppercase: System.out.println("Starts with uppercase: " + Character.isUpperCase(password.charAt(0)));. Comparison: System.out.println("s1 == s2 (literals): " + (s1 == s2)); etc.

8BigDecimal — Precise Invoice Calculator

Think about it: Financial applications must be exact. Using double, 0.1 + 0.2 = 0.30000000000000004. That error compounds across millions of transactions! BigDecimal gives exact results. This exercise also uses Integer.parseInt() for parsing quantities (wrapper classes).

Create an invoice calculator using BigDecimal. Parse quantity strings using Integer.parseInt() (wrapper class). Calculate subtotal = price × quantity using multiply(). Apply 16% tax using multiply(). Calculate total using add(). Compare results with double arithmetic. Use String constructor for BigDecimal!

Expected Output--- BigDecimal Invoice --- Item: Widget, Qty: 3, Price: 19.99 Subtotal: 59.97 Tax (16%): 9.5952 Total: 69.5652 --- double comparison --- double total: 69.56520000000001

Your Code

import java.math.BigDecimal;

public class InvoiceCalculator {
    public static void main(String[] args) {
        // Parse quantity from String using Integer.parseInt()
        String qtyString = "3";
        int qty = Integer.parseInt(qtyString);

        // Create BigDecimal price (use String constructor!)
        BigDecimal price = new BigDecimal("19.99");
        BigDecimal quantity = new BigDecimal(qtyString);

        System.out.println("--- BigDecimal Invoice ---");
        System.out.println("Item: Widget, Qty: " + qty + ", Price: " + price);

        // Calculate subtotal: price.multiply(quantity)

        System.out.println("Subtotal: " + subtotal);

        // Tax rate: new BigDecimal("0.16")
        // Calculate tax: subtotal.multiply(taxRate)


        System.out.println("Tax (16%): " + tax);

        // Calculate total: subtotal.add(tax)

        System.out.println("Total: " + total);

        // Compare with double
        System.out.println("--- double comparison ---");
        double dTotal = 19.99 * 3 * 1.16;
        System.out.println("double total: " + dTotal);
    }
}

Subtotal: BigDecimal subtotal = price.multiply(quantity);. Tax: BigDecimal taxRate = new BigDecimal("0.16"); BigDecimal tax = subtotal.multiply(taxRate);. Total: BigDecimal total = subtotal.add(tax);. Always use the String constructor: new BigDecimal("0.16") not new BigDecimal(0.16)!

9Array of Objects — Product Inventory

Think about it: An online store needs to manage its product catalog. Each product has a name, price, and stock quantity. By storing products in an array of objects, you can loop through them to generate reports — find the most expensive item, and calculate the total inventory value (price × quantity for each). This is a very common real-world pattern!

Create a Product class with fields name (String), price (double), and quantity (int). Create an array of 3 products. Loop through the array to: (1) print each product, (2) find the most expensive product, (3) calculate the total inventory value (sum of price × quantity).

Expected Output--- Inventory --- Laptop: $800.0 x 5 Phone: $500.0 x 12 Tablet: $350.0 x 8 Most expensive: Laptop ($800.0) Total inventory value: $12800.0

Your Code

class Product {
    String name;
    double price;
    int quantity;

    // Constructor

}

public class TestInventory {
    public static void main(String[] args) {
        // Create array of 3 products
        // Product("Laptop", 800.0, 5), Product("Phone", 500.0, 12)
        // Product("Tablet", 350.0, 8)


        // Print all products
        System.out.println("--- Inventory ---");
        // Use a for-each loop


        // Find the most expensive product
        Product expensive = products[0];
        // Loop and compare


        System.out.println("Most expensive: " + expensive.name + " ($" + expensive.price + ")");

        // Calculate total inventory value (price * quantity for each)
        double totalValue = 0;
        // Loop and calculate


        System.out.println("Total inventory value: $" + totalValue);
    }
}

Constructor: Product(String name, double price, int quantity) { this.name = name; this.price = price; this.quantity = quantity; }. Array:

Product[] products = { new Product("Laptop", 800.0, 5), new Product("Phone", 500.0, 12), new Product("Tablet", 350.0, 8) };

. Print: for (Product p : products) System.out.println(p.name + ": $" + p.price + " x " + p.quantity);. Most expensive: for (Product p : products) if (p.price > expensive.price) expensive = p;. Value: for (Product p : products) totalValue += p.price * p.quantity;.

10Array of Objects — Employee Bonus Calculator

Think about it: An HR system stores employees with their department and salary. Using an array of objects, you can generate a bonus report (10% of salary for each), filter by department using .equals(), and find the highest-paid employee. This combines arrays of objects with String comparison and arithmetic.

Create an Employee class with fields name (String), department (String), and salary (double). Create an array of 4 employees. Loop to: (1) print each employee with a 10% bonus, (2) count how many work in "IT" using .equals(), (3) find the employee with the highest salary.

Expected Output--- Bonus Report --- Sami (IT): Salary=3000.0, Bonus=300.0 Nour (HR): Salary=2800.0, Bonus=280.0 Rami (IT): Salary=3500.0, Bonus=350.0 Dana (HR): Salary=2900.0, Bonus=290.0 IT employees: 2 Highest salary: Rami ($3500.0)

Your Code

class Employee {
    String name;
    String department;
    double salary;

    // Constructor

}

public class TestBonus {
    public static void main(String[] args) {
        // Create array of 4 employees
        // Employee("Sami", "IT", 3000), Employee("Nour", "HR", 2800)
        // Employee("Rami", "IT", 3500), Employee("Dana", "HR", 2900)


        // Print bonus report (10% of salary)
        System.out.println("--- Bonus Report ---");
        // Loop: print name, department, salary, and bonus


        // Count IT department employees
        int itCount = 0;
        // Loop and count using .equals("IT")


        System.out.println("IT employees: " + itCount);

        // Find employee with highest salary
        Employee top = employees[0];
        // Loop and compare


        System.out.println("Highest salary: " + top.name + " ($" + top.salary + ")");
    }
}

Constructor:

Employee(String name, String department, double salary) { this.name = name; this.department = department; this.salary = salary; }

. Array:

Employee[] employees = { new Employee("Sami", "IT", 3000), new Employee("Nour", "HR", 2800), new Employee("Rami", "IT", 3500), new Employee("Dana", "HR", 2900) };

. Bonus:

for (Employee e : employees) { double bonus = e.salary * 0.10; System.out.println(e.name + " (" + e.department + "): Salary=" + e.salary + ", Bonus=" + bonus); }

. Count: if (e.department.equals("IT")) itCount++;. Top: if (e.salary > top.salary) top = e;.

11Composition — Car & Engine

Think about it: A Car has an Engine that is built specifically for it — the engine is created inside the Car constructor, not passed from outside. If the car is destroyed, the engine goes with it. This is composition: a strong "owns" relationship where the part cannot exist independently of the whole.

Create an Engine class with fields horsepower (int) and type (String). Create a Car class with a field model (String) and an Engine field. The Car constructor takes model, hp, and engineType and creates the Engine inside using new Engine(hp, engineType). Add a display() method. Show that when the car is set to null, the engine is gone too.

Expected OutputCar: Toyota Camry, Engine: 203HP V4 Car destroyed — engine is gone too (composition)

Your Code

class Engine {
    int horsepower;
    String type;

    // Constructor

}

class Car {
    String model;
    Engine engine;  // Composition — created inside

    // Constructor: takes model, hp, engineType
    // Create Engine INSIDE with new Engine(hp, engineType)


    // display() — print car model, engine horsepower and type

}

public class TestCar {
    public static void main(String[] args) {
        Car car = new Car("Toyota Camry", 203, "V4");
        car.display();

        car = null;
        System.out.println("Car destroyed — engine is gone too (composition)");
    }
}

Engine: Engine(int horsepower, String type) { this.horsepower = horsepower; this.type = type; }. Car constructor: Car(String model, int hp, String engineType) { this.model = model; this.engine = new Engine(hp, engineType); }. Key: new Engine(hp, engineType) is created INSIDE the Car — that's composition. Display: System.out.println("Car: " + model + ", Engine: " + engine.horsepower + "HP " + engine.type);.

12Aggregation — Team & Player

Think about it: A football Team has a captain and a topScorer, but players exist independently — they were recruited from outside and can join another team if this one is dissolved. This is aggregation: a weak "uses" relationship where the parts are passed in and survive on their own.

Create a Player class with fields name (String) and position (String). Create a Team class with name (String), captain (Player), and topScorer (Player). The Team constructor receives Player objects as parameters (aggregation — not created inside). Add a display() method. Show that players still exist after the team is set to null.

Expected OutputTeam: Al-Ahli Captain: Khalid (Midfielder) Top Scorer: Yazan (Forward) Team dissolved! Players still exist: Khalid, Yazan

Your Code

class Player {
    String name;
    String position;

    // Constructor

}

class Team {
    String name;
    Player captain;    // Aggregation — passed in
    Player topScorer;  // Aggregation — passed in

    // Constructor: takes name, captain (Player), topScorer (Player)
    // Assign both from parameters (NOT created inside)


    // display() — print team name, captain, and top scorer

}

public class TestTeam {
    public static void main(String[] args) {
        // Create players outside
        Player p1 = new Player("Khalid", "Midfielder");
        Player p2 = new Player("Yazan", "Forward");

        // Create team — players passed in (aggregation)
        Team team = new Team("Al-Ahli", p1, p2);
        team.display();

        // Dissolve the team
        team = null;
        System.out.println("Team dissolved!");
        System.out.println("Players still exist: " + p1.name + ", " + p2.name);
    }
}

Player: Player(String name, String position) { this.name = name; this.position = position; }. Team constructor:

Team(String name, Player captain, Player topScorer) { this.name = name; this.captain = captain; this.topScorer = topScorer; }

. Key: players are passed in, NOT created inside — that's aggregation. Display:

System.out.println("Team: " + name); System.out.println("  Captain: " + captain.name + " (" + captain.position + ")"); System.out.println("  Top Scorer: " + topScorer.name + " (" + topScorer.position + ")");

.

13Composition + Aggregation — University Department

Think about it: A Department owns a Course that was designed specifically for it — composition (created inside). But the Instructor teaching the course was hired from outside and can teach elsewhere — aggregation (passed in). This exercise combines both relationships in one class, reinforcing the difference.

Create a Course class with fields title (String) and credits (int). Create an Instructor class with fields name (String) and specialization (String). Create a Department class that uses composition for Course (created inside with new Course(courseTitle, credits)) and aggregation for Instructor (passed in). Add a display() method. Show that the Instructor survives after the department is closed.

Expected OutputDepartment: Computer Science Course: Intro to DB (3 credits) Instructor: Dr. Huda — Databases Department closed! Instructor still exists: Dr. Huda

Your Code

class Course {
    String title;
    int credits;

    // Constructor

}

class Instructor {
    String name;
    String specialization;

    // Constructor

}

class Department {
    String name;
    Course course;         // Composition — created inside
    Instructor instructor; // Aggregation — passed in

    // Constructor: takes name, courseTitle, credits, Instructor
    // Create Course INSIDE with new Course(courseTitle, credits)
    // Assign Instructor from parameter


    // display() — print department, course info, and instructor

}

public class TestDepartment {
    public static void main(String[] args) {
        // Create instructor outside
        Instructor prof = new Instructor("Dr. Huda", "Databases");

        // Create department — Course inside (composition), Instructor passed in (aggregation)
        Department dept = new Department("Computer Science", "Intro to DB", 3, prof);
        dept.display();

        // Close department
        dept = null;
        System.out.println("Department closed!");
        System.out.println("Instructor still exists: " + prof.name);
    }
}

Course: Course(String title, int credits) { this.title = title; this.credits = credits; }. Instructor: Instructor(String name, String specialization) { this.name = name; this.specialization = specialization; }. Department constructor:

Department(String name, String courseTitle, int credits, Instructor instructor) { this.name = name; this.course = new Course(courseTitle, credits); this.instructor = instructor; }

. Key: new Course(...) = composition (inside), this.instructor = instructor = aggregation (passed in). Display: print name, course.title, course.credits, instructor.name, instructor.specialization.