Shape interface and runtime binding

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.

interface Shape { double area(); void display(); }

Shape is an interface declaring area and display. It specifies behaviour without prescribing the fields or formula of a concrete shape.

    static class Circle implements Shape {
        final double radius; Circle(double r){radius=r;}
        @Override public double area(){return Math.PI*radius*radius;}
        @Override public void display(){money("Circle area",area());}
    }

The constructor stores r. area uses Math.PI times radius squared. The public overrides fulfil the interface; display calls the area method and formats the numeric result.

    static class Rectangle implements Shape {
        final double length,width; Rectangle(double l,double w){length=l;width=w;}
        @Override public double area(){return length*width;}
        @Override public void display(){money("Rectangle area",area());}
    }

Store both dimensions and return their product from area. display uses the same method contract as Circle, despite the different representation.

    static class Triangle implements Shape {
        final double base,height; Triangle(double b,double h){base=b;height=h;}
        @Override public double area(){return base*height/2;}
        @Override public void display(){money("Triangle area",area());}
    }

Store the perpendicular base/height values and compute base*height/2. Because the fields are double, this division can produce a fractional area.

    // radius/rectangle length/rectangle width/triangle base/triangle height, one per line.
    public static void main(String[] args) {
        try {
            Shape[] shapes={new Circle(number(0,1000000)),new Rectangle(number(0,1000000),number(0,1000000)),new Triangle(number(0,1000000),number(0,1000000))};
            for(Shape shape:shapes)shape.display();

Read five nonnegative finite dimensions in the documented order. Construct three concrete objects, store them in a Shape array and call display on each; Java selects the actual subtype method.

        } 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.