Hierarchical inheritance for vehicle rentals

import java.util.*;

public class Main {
    private static final Scanner IN = new Scanner(System.in).useLocale(Locale.ROOT);

java.util.* imports utility type names such as Scanner, Locale and collections. Main is the public class matching Main.java. The private static final IN field holds one shared Scanner for System.in; final prevents replacing that reference. The scanner uses Locale.ROOT.

    static String text() {
        if (!IN.hasNextLine()) throw new IllegalArgumentException("Incomplete input.");
        String value = IN.nextLine().trim();
        if (value.isEmpty() || value.length() > 200) throw new IllegalArgumentException("Text must have 1–200 characters.");
        return value;
    }

text checks whether a line exists, reads it and removes leading/trailing whitespace. Reject empty text and lengths above 200 by throwing IllegalArgumentException. Otherwise return the string. One field is read per line, so these helpers do not mix nextInt with leftover newlines.

    static int integer(int low, int high) {
        int value = Integer.parseInt(text());
        if (value < low || value > high) throw new IllegalArgumentException("Integer out of range.");
        return value;
    }

Integer.parseInt converts the returned string to int or throws NumberFormatException, a subtype of IllegalArgumentException. Reject values outside the caller’s inclusive low/high limits, then return the accepted integer.

    static double number(double low, double high) {
        double value = Double.parseDouble(text());
        if (!Double.isFinite(value) || value < low || value > high) throw new IllegalArgumentException("Number out of range.");
        return value;
    }

Double.parseDouble reads the string as a double. Double.isFinite rejects NaN and infinities as well as the explicit low/high range check. Return only a finite accepted value; exceptions transfer control to a matching catch block.

    static void money(String label, double value) { System.out.printf(Locale.ROOT, "%s: %.2f%n", label, value); }

money is a formatting helper: %s prints the label, %.2f prints two decimal places, and %n ends the line. Locale.ROOT fixes locale-sensitive formatting. The helper can also display non-currency quantities; it does not change the stored value.

static abstract class Vehicle {
        final String vehicleNo, brand;
        final double baseFare;
        int billedDays;
        Vehicle(String no, String brand, double fare) { vehicleNo=no; this.brand=brand; baseFare=fare; }
        abstract double calculateFare(int days);

Vehicle stores number, brand, base fare and billed days. Its constructor initialises the common fields. Concrete vehicles must implement calculateFare(int days).

        void displayBill() { System.out.println(getClass().getSimpleName()+" | "+vehicleNo+" | "+brand+" | days "+billedDays); money("Fare",calculateFare(billedDays)); }
        void validateDays(int days) { if (days<1 || days>365) throw new IllegalArgumentException("Days must be 1–365."); billedDays=days; }
    }

displayBill prints identity and calculates for stored billedDays. validateDays accepts 1–365 and remembers the accepted duration. Each concrete fare method calls it before calculating.

    static class Car extends Vehicle {
        final int noOfSeats; final boolean acAvailable;
        Car(String no,String brand,double fare,int seats,boolean ac) { super(no,brand,fare); noOfSeats=seats; acAvailable=ac; }
        @Override double calculateFare(int days) { validateDays(days); return days*(baseFare+(acAvailable?200:0)); }
    }

The Car constructor delegates common fields with super and stores seat/AC information. The override charges days times base fare plus a daily 200 AC surcharge when enabled.

    static class Bike extends Vehicle {
        final boolean helmetRequired, geared;
        Bike(String no,String brand,double fare,boolean helmet,boolean geared) { super(no,brand,fare); helmetRequired=helmet; this.geared=geared; }
        @Override double calculateFare(int days) { validateDays(days); return days*(baseFare+(geared?50:0)); }
    }

Bike records helmetRequired and geared. Its fare override adds a daily 50 only for geared; the stored helmet flag does not add another charge in this implementation.

    static class SUV extends Vehicle {
        final boolean fourWheelDrive; final int luxuryLevel;
        SUV(String no,String brand,double fare,boolean drive,int luxury) { super(no,brand,fare); fourWheelDrive=drive; luxuryLevel=luxury; }
        @Override double calculateFare(int days) { validateDays(days); return days*(baseFare+(fourWheelDrive?500:0)+luxuryLevel*100); }
    }

SUV stores four-wheel-drive and luxury level. The override adds 500 per day for four-wheel drive and 100 per luxury level per day before multiplying by days.

    // Rental days. Three sample vehicles make the overriding behavior visible.
    public static void main(String[] args) {
        try {
            int days=integer(1,365);
            Vehicle[] vehicles={new Car("CAR01","Maruti",1000,5,true),new Bike("BIKE01","Honda",300,true,true),new SUV("SUV01","Mahindra",2000,true,2)};
            for (Vehicle vehicle:vehicles) { vehicle.calculateFare(days); vehicle.displayBill(); }

Read the duration, construct fixed car/bike/SUV examples and iterate through Vehicle references. The first calculateFare call validates and stores days; displayBill calls the override again for the same duration without adding a cumulative charge.

        } catch (IllegalArgumentException e) { System.out.println("Invalid input: "+e.getMessage()); }
    }
}

The catch handles IllegalArgumentException, including invalid numeric strings from the helpers, and prints its message. The final braces close main and Main. Java objects become eligible for garbage collection when no live reference needs them; this program does not manually free them.