Abstract media files and dynamic dispatch

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 MediaFile {
        final String fileName; final int duration; final double fileSize;
        MediaFile(String name,int duration,double size) { fileName=name;this.duration=duration;fileSize=size; }
        abstract void play(); abstract void pause(); abstract void stop();
        void message(String type,String action) { System.out.println(type+" "+action+": "+fileName); }
    }

MediaFile keeps metadata and requires play, pause and stop methods. Its concrete message helper formats a type/action/file-name line. An abstract class can supply shared implementation while requiring subtype behaviour.

    static class AudioFile extends MediaFile {
        AudioFile(String n,int d,double s){super(n,d,s);}
        @Override void play(){message("Audio","play");} @Override void pause(){message("Audio","pause");} @Override void stop(){message("Audio","stop");}
    }

AudioFile passes common metadata to super and overrides all three abstract operations. The methods print simulation messages; no audio file is opened or decoded.

    static class VideoFile extends MediaFile {
        VideoFile(String n,int d,double s){super(n,d,s);}
        @Override void play(){message("Video","play");} @Override void pause(){message("Video","pause");} @Override void stop(){message("Video","stop");}
    }

VideoFile supplies the same operations with video labels. Matching signatures enable use through MediaFile references.

    static class LiveStream extends MediaFile {
        LiveStream(String n,int d,double s){super(n,d,s);}
        @Override void play(){message("Live","play");} @Override void pause(){message("Live","pause (simulation)");} @Override void stop(){message("Live","stop");}
    }

LiveStream overrides play, pause and stop. Its pause text explicitly says simulation; this example does not pause a real network stream.

    public static void main(String[] args) {
        MediaFile[] files={new AudioFile("lesson.mp3",120,5),new VideoFile("demo.mp4",300,50),new LiveStream("class-live",0,0)};
        for(MediaFile file:files){file.play();file.pause();file.stop();}
    }
}

main creates one object of each subtype and loops over MediaFile references. Each call resolves at runtime to the receiver’s override. The final braces close the loop, method and Main.