This code snippet should do the trick:

private String readLine(String format, Object... args) throws IOException {
    if (System.console() != null) {
        return System.console().readLine(format, args);
    }
    System.out.print(String.format(format, args));
    BufferedReader reader = new BufferedReader(new InputStreamReader(
            System.in));
    return reader.readLine();
}

private char[] readPassword(String format, Object... args)
        throws IOException {
    if (System.console() != null)
        return System.console().readPassword(format, args);
    return this.readLine(format, args).toCharArray();
}

While testing in Eclipse, your password input will be shown in clear. At least, you will be able to test. Just don't type in your real password while testing. Keep that for production use ;).

To read from Standard input (command line input) you must use some kind of stream reader to read the System.in stream. An InputStreamReader initialised by

    InputStreamReader(System.in) 

lets you read character by character. However, I suggest wrapping this with a BufferedReader:

    BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
    String inputLine = reader.readLine();

Must import

    java.io.*;

That is because System.console()is returning null. The official documentation states (bold is mine to emphasize):

public static Console console()

Returns the unique Console object associated with the current Java virtual machine, if any.

Returns: The system console, if any, otherwise null.

You can see it here.

It looks like System.console() is not behaving as expected in your environment, possibly because of how the JVM or IDE is configured. Sometimes, when running Java applications from IDEs or certain environments, System.console() may not return null even if the application isn't actually being run from a terminal.

Here’s an alternative approach to determine if your Java application is running in a terminal or not:

Using System.getenv() and System.getProperty()

You can use environment variables and system properties to infer whether your application is running in a terminal.

• On Windows, the presence of the COMSPEC environment variable typically indicates a terminal or command prompt environment.
• On Unix-like systems, the presence of the TERM environment variable suggests that the application might be running in a terminal.

private static boolean isRunningInTerminal() {
        // Check if environment variables typically set for terminals are present
        String os = System.getProperty("os.name").toLowerCase();
        if (os.contains("windows")) {
            String comSpec = System.getenv("COMSPEC");
            return comSpec != null && !comSpec.isEmpty();
        } else {
            String term = System.getenv("TERM");
            return term != null && !term.isEmpty();
        }
    }

You could also check for the presence of specific system properties or runtime configurations that are indicative of running in a terminal environment. add additional debugging outputs to understand the environment better:

System.out.println("Console: " + System.console());
System.out.println("COMSPEC: " + System.getenv("COMSPEC"));
System.out.println("TERM: " + System.getenv("TERM"));
System.out.println("OS Name: " + System.getProperty("os.name"));
System.out.println("OS Version: " + System.getProperty("os.version"));
System.out.println("Java Version: " + System.getProperty("java.version"));
System.out.println("User Directory: " + System.getProperty("user.dir"));
System.out.println("Current Working Directory: " + System.getProperty("user.dir"));

This will help you determine what environment variables and properties are available, and why System.console() might not be returning null.

System.console() returns null if there is no console.

You can work round this either by adding a layer of indirection to your code or by running the code in an external console and attaching a remote debugger.

Also, According to the docs:

If the virtual machine is started automatically, for example by a background job scheduler, then it will typically not have a console.