Código ruim:

try {
    fazerAlgumaCoisa();
} catch(AlgumaException e) {
    // Nunca vai acontecer.
}
fazerMaisCoisas();

Aqui o desenvolvedor executa algum código em um bloco try/catch. Ele não quer relançar a exceção que os métodos chamados "irritantemente" declaram poder lançar (throws). Como o desenvolvedor é esperto, ele sabe que nessa situação em particular a exceção nunca será lançada. Então ele apenas insere um bloco catch vazio. Ele até mesmo coloca um adorável comentário no bloco catch vazio, mas elas são as famosas últimas palavras... O problema aqui é: como ele pode ter certeza? E se a implementação do método chamado muda? E se a exceção ocorrer em um caso especial que o desenvolvedor não pensou? O código depois do try/catch pode fazer algo errado nessa situação. A exceção vai passar completamente despercebida. O código pode ser muito mais confiável se lançar uma runtime exception neste caso. Isto funciona como uma asserção e é aderente ao princípio de "falhar cedo". O desenvolvedor irá perceber se a sua premissa estava errada. O código depois do try/catch não será mais executado se a exceção ocorrer (contrariando toda a expectativa). Se a exceção realmente nunca ocorrer, ótimo! Nada muda.

Código mais confiável:

try {
    fazerAlgumaCoisa();
} catch(AlgumaException e) {
    // Espero que nunca aconteça.
    throw new IllegalStateException(
            e.getMessage(), e);
}
fazerMaisCoisas();