Java Classes and Objects Explained — Build Real OOP Programs From Scratch

// A class is a blueprint — we're describing what a BankAccount looks like
// This file defines the class but doesn't create any account yet
public class BankAccount {

    // --- FIELDS (instance variables) ---
    // These describe the STATE of a BankAccount object
    // Every BankAccount object will have its OWN copy of these
    String accountHolderName;  // who owns this account
    String accountNumber;      // unique identifier for the account
    double balance;            // how much money is currently in it

    // --- CONSTRUCTOR ---
    // A constructor is a special method that runs automatically when
    // you create a new object. Its job is to set the initial state.
    // Notice: same name as the class, no return type
    public BankAccount(String holderName, String number, double openingBalance) {
        accountHolderName = holderName;   // store the name we were given
        accountNumber     = number;        // store the account number
        balance           = openingBalance; // set the starting balance
    }

    // --- METHODS ---
    // These describe the BEHAVIOUR a BankAccount can perform

    // Deposit money into the account
    public void deposit(double amount) {
        if (amount <= 0) {
            System.out.println("Deposit amount must be positive.");
            return; // stop here — don't proceed with bad input
        }
        balance = balance + amount; // increase the balance
        System.out.println("Deposited $" + amount + " — New balance: $" + balance);
    }

    // Withdraw money from the account
    public void withdraw(double amount) {
        if (amount > balance) {
            System.out.println("Insufficient funds. Current balance: $" + balance);
            return; // stop — can't withdraw more than available
        }
        balance = balance - amount; // reduce the balance
        System.out.println("Withdrew $" + amount + " — New balance: $" + balance);
    }

    // Print a summary of this account's current state
    public void printStatement() {
        System.out.println("--- Account Statement ---");
        System.out.println("Holder : " + accountHolderName);
        System.out.println("Number : " + accountNumber);
        System.out.println("Balance: $" + balance);
        System.out.println("-------------------------");
    }

    // main method — the entry point Java uses to run the program
    public static void main(String[] args) {

        // Creating two OBJECTS (instances) from the same BankAccount class
        // Each object is completely independent — its own data, its own state
        BankAccount alicesAccount = new BankAccount("Alice Chen", "ACC-1001", 500.00);
        BankAccount bobsAccount   = new BankAccount("Bob Martins", "ACC-1002", 1200.00);

        // Working with Alice's account
        alicesAccount.deposit(250.00);   // Alice deposits $250
        alicesAccount.withdraw(100.00);  // Alice withdraws $100
        alicesAccount.printStatement();  // print Alice's current state

        System.out.println(); // blank line for readability

        // Working with Bob's account — completely separate from Alice's
        bobsAccount.withdraw(400.00);    // Bob withdraws $400
        bobsAccount.printStatement();    // print Bob's current state
    }
}

// Let's model a Car to reinforce how multiple objects stay independent
public class CarShowroom {

    // --- The Car class blueprint ---
    // (In a real project this would be its own file — Car.java)
    static class Car {
        String make;    // e.g. "Toyota"
        String model;   // e.g. "Corolla"
        String colour;  // e.g. "Red"
        int    currentSpeedKph; // how fast it's going right now

        // Constructor — sets up a car's initial state when it's created
        public Car(String make, String model, String colour) {
            this.make   = make;   // 'this.make' = the field; 'make' = the parameter
            this.model  = model;
            this.colour = colour;
            this.currentSpeedKph = 0; // every new car starts stationary
        }

        // Accelerate the car by a given amount
        public void accelerate(int kph) {
            currentSpeedKph += kph; // += means 'add kph to current speed'
            System.out.println(colour + " " + make + " " + model
                + " accelerates to " + currentSpeedKph + " kph");
        }

        // Brake the car — slow it down
        public void brake(int kph) {
            currentSpeedKph -= kph; // reduce speed
            if (currentSpeedKph < 0) currentSpeedKph = 0; // can't go below zero
            System.out.println(colour + " " + make + " " + model
                + " slows to " + currentSpeedKph + " kph");
        }
    }

    public static void main(String[] args) {

        // 'new' creates a fresh Car object and returns a reference to it
        Car redToyota  = new Car("Toyota",  "Corolla", "Red");
        Car blueFord   = new Car("Ford",    "Focus",   "Blue");
        Car greenHonda = new Car("Honda",   "Civic",   "Green");

        // Each car manages its own speed independently
        redToyota.accelerate(60);  // red Toyota speeds up
        blueFord.accelerate(80);   // blue Ford speeds up — red Toyota unaffected
        redToyota.accelerate(20);  // red Toyota goes faster again
        greenHonda.accelerate(50); // green Honda joins in
        blueFord.brake(30);        // blue Ford slows down — others unaffected

        // Let's confirm the final speeds of each object
        System.out.println("\n--- Final Speeds ---");
        System.out.println("Red Toyota  : " + redToyota.currentSpeedKph  + " kph");
        System.out.println("Blue Ford   : " + blueFord.currentSpeedKph   + " kph");
        System.out.println("Green Honda : " + greenHonda.currentSpeedKph + " kph");
    }
}

// Demonstrates constructor overloading — multiple constructors in one class
public class ProductCatalog {

    static class Product {
        String name;
        double price;
        int    stockQuantity;
        String category;

        // Constructor 1: Full details — use this when you have everything upfront
        public Product(String name, double price, int stockQuantity, String category) {
            this.name          = name;
            this.price         = price;
            this.stockQuantity = stockQuantity;
            this.category      = category;
        }

        // Constructor 2: Price and name only — stock defaults to 0, category to "Uncategorised"
        // Useful when you're adding new products that haven't arrived in stock yet
        public Product(String name, double price) {
            this.name          = name;
            this.price         = price;
            this.stockQuantity = 0;               // sensible default
            this.category      = "Uncategorised"; // sensible default
        }

        // Method to restock — adds more units to current stock
        public void restock(int unitsAdded) {
            stockQuantity += unitsAdded;
            System.out.println(name + " restocked. New quantity: " + stockQuantity);
        }

        // Method to display product details in a readable format
        public void displayDetails() {
            System.out.println("Product  : " + name);
            System.out.println("Category : " + category);
            System.out.println("Price    : $" + price);
            System.out.println("In Stock : " + stockQuantity + " units");
            System.out.println("---");
        }
    }

    public static void main(String[] args) {

        // Using Constructor 1 — all four arguments provided
        Product laptop = new Product("ThinkPad X1", 1299.99, 15, "Electronics");

        // Using Constructor 2 — only name and price; stock and category use defaults
        Product newArrival = new Product("Wireless Keyboard", 49.99);

        laptop.displayDetails();
        newArrival.displayDetails();

        // The new arrival just came in — let's update its stock
        newArrival.restock(50);
        System.out.println();
        newArrival.displayDetails(); // display again to see updated stock
    }
}

public class StudentGradeTracker {

    // The Student class — a self-contained blueprint for a student record
    static class Student {

        // PRIVATE fields — only code inside this class can touch them directly
        // This is encapsulation: protect the data, control how it's accessed
        private String studentName;
        private int    studentId;
        private double[] examScores;  // array to hold multiple exam scores
        private int    scoresRecorded; // how many scores have been added so far

        // Constructor — sets up the student with a name, ID and exam capacity
        public Student(String name, int id, int maxExams) {
            this.studentName    = name;
            this.studentId      = id;
            this.examScores     = new double[maxExams]; // reserve space for scores
            this.scoresRecorded = 0; // no exams taken yet
        }

        // PUBLIC method — adds an exam score to this student's record
        public void addExamScore(double score) {
            if (scoresRecorded >= examScores.length) {
                System.out.println("Cannot add more scores — all exam slots are full.");
                return;
            }
            if (score < 0 || score > 100) {
                System.out.println("Invalid score. Must be between 0 and 100.");
                return;
            }
            examScores[scoresRecorded] = score; // store the score at the next open slot
            scoresRecorded++;                    // move the slot counter forward
            System.out.println("Score " + score + " recorded for " + studentName);
        }

        // Calculates and returns the average of all recorded scores
        public double calculateAverage() {
            if (scoresRecorded == 0) return 0.0; // avoid dividing by zero
            double total = 0;
            for (int i = 0; i < scoresRecorded; i++) {
                total += examScores[i]; // add each score to the running total
            }
            return total / scoresRecorded; // average = total divided by count
        }

        // Converts a numeric average into a letter grade
        public String getLetterGrade() {
            double average = calculateAverage();
            if (average >= 90) return "A";
            if (average >= 80) return "B";
            if (average >= 70) return "C";
            if (average >= 60) return "D";
            return "F";
        }

        // Getter — the only approved way for outside code to read the student's name
        public String getStudentName() {
            return studentName;
        }

        // Prints a full, formatted report for this student
        public void printReport() {
            System.out.println("=============================");
            System.out.println("Student  : " + studentName);
            System.out.println("ID       : " + studentId);
            System.out.printf ("Average  : %.1f%%\n", calculateAverage()); // 1 decimal place
            System.out.println("Grade    : " + getLetterGrade());
            System.out.println("Exams    : " + scoresRecorded + " recorded");
            System.out.println("=============================");
        }
    }

    // Main method — where execution starts
    public static void main(String[] args) {

        // Create two student objects — completely independent
        Student priya = new Student("Priya Sharma",  1001, 4);
        Student james = new Student("James Okafor",  1002, 4);

        // Add exam scores for Priya
        priya.addExamScore(88.5);
        priya.addExamScore(92.0);
        priya.addExamScore(79.5);
        priya.addExamScore(95.0);

        // Add exam scores for James
        james.addExamScore(74.0);
        james.addExamScore(68.5);
        james.addExamScore(71.0);

        // Attempt to add a 5th score to Priya's record (max is 4 — should warn us)
        priya.addExamScore(85.0);

        System.out.println(); // blank line before the reports

        // Print both student reports
        priya.printReport();
        james.printReport();
    }
}