Sobrecarga do método println() | Java e java.lang: programe com a classe Object e String

Olá Nathan, tudo bem?

Realmente temos o Object que é uma referência genérica, e a grande questão do overloading, é um outro método, no caso o valueOf

Para bool

    public void println(boolean x) {
        if (getClass() == PrintStream.class) {
            writeln(String.valueOf(x));
        } else {
            synchronized (this) {
                print(x);
                newLine();
            }
        }
    }

Para char

    public void println(char x) {
        if (getClass() == PrintStream.class) {
            writeln(String.valueOf(x));
        } else {
            synchronized (this) {
                print(x);
                newLine();
            }
        }
    }

Iguais, correto ?

A grande questão é que o valueOf são bem diferentes, veja:

    public static String valueOf(boolean b) {
        return b ? "true" : "false";
    }

    public static String valueOf(char c) {
        if (COMPACT_STRINGS && StringLatin1.canEncode(c)) {
            return new String(StringLatin1.toBytes(c), LATIN1);
        }
        return new String(StringUTF16.toBytes(c), UTF16);
    }

Então se o println fosse apenas de Object, invocaríamos sempre o valueOf de object que é esse daqui:

    public static String valueOf(Object obj) {
        return (obj == null) ? "null" : obj.toString();
    }

Mas não existe toString de tipos primitivos como: char, int, boolean, double, ou seja, tomaríamos um erro, esses métodos são estão disponíveis nas classes Integer, Boolean, Double

Então o Overloading no println auxilia a trabalhar com os tipos primitivos e os que extendem de Object :)

Existem alguns tipos de valueOf que utilizam o toString, por exemplo:

    public static String valueOf(double d) {
        return Double.toString(d);
    }

E ai um outro ponto seria o seguinte: No toString eu faço uma verificação de nulidade, mas para os tipos primitivos é impossível ter um valor nulo, é gerado um erro de compilação:

int  vinte = null;

Então com esse overloading eu evito fazer comparações desnecessárias :)

Ficou Claro?

Abraços e Bons Estudos!