THROWS na assinatura do método

Oi Anelise, tudo bem ?

Quando colocamos o throw na assinatura estamos falando que sabemos que nosso código pode gerar uma exception mas naquele momento não estamos interessados em tratar ela e quem for usar o nosso método será responsável de fazer o tratamento.

Olá Anelise!

Vamos lá: o throws é usado para disparar uma exception enquanto o try/catch é usado para tratar uma exception.

Tá... mas o que isso quer dizer? ;)

Vou usar um exemplo para ficar um pouco mais claro, ok?

Digamos que você tenha um método bla() que precisa do valor da divisão entre dois valores. Para isso, você chama o método divide().

public void bla() {
    int a; 
    int b;

    double resposta = divide(a,b);
...
}

Sabemos que não existe divisão por 0 e que pode dar erro, então disparamos uma IllegalArgumentException no método divide() para alertar caso ocorra esta situação. Neste caso, usamos o throw

public double divide(int numerador, int denominador) throws IllegalArgumentException {
    if(denominador==0) {
        throw new IllegalArgumentException("divisão por 0");
    }
    return numerador/denominador;
}

Do jeito que está, o método bla() vai compilar normalmente. Se o método divide() disparar uma exception, o bla() vai "quebrar", ou seja, vai parar a execução pois ele não saberá o que fazer com a exception. Para que o código não quebre e pare no meio, é preciso tratar essa exception e para isso usamos o try/catch.

Logo, nosso bla() ficaria assim:

public void bla() {
    int a; 
    int b;
    double resposta;
    try {
        resposta = divide(a,b);
    } catch (IllegalArgumentException e) {
        System.out.println("Quebrou");
    }
...
}

Neste caso, o código não vai quebrar. O método bla() está tratando um possível erro e alterando o fluxo da compilação.

Pera... Mas porque o bla() compilava anteriormente, mesmo correndo risco de quebrar no meio? - Isso ocorre pois a exception disparada como resposta pelo método divide() não exigia tratamento em quem chamava o método.

Existem vários tipos de exceptions que dividimos entre checked e unchecked.

As exceptions unchecked são do tipo RuntimeException ou filhas de RuntimeException e não precisam ser tratadas, ou seja, ao chamar um método que pode disparar esse tipo de exception o uso do try/catch é facultativo (usa se quiser). É o caso do IllegalArgumentException, que é filha de RuntimeException - não é obrigatório tratá-la.

Já as demais exceptions são checked e exigem tratamento, ou seja, ao chamar um método que pode disparar uma exception checked, o uso do try/catch é obrigatório.

Ou seja, no nosso exemplo, se o método divide() disparasse uma Exception ao invés do IllegalArgumentException, o método bla() não compilaria sem o try/catch.

Bom, espero ter ajudado!! :)

Ah entendi, agora tudo ficou mais claro. Obrigada Matheus Brandino e Tais Batuira a dica de vocês foram excelentes!! Muito agradecida.