Exceptions

O que você disse sobre empurrar a exceção para o método que o chamou está correto.
Isso significa que, se no método não houver nenhum tratamento com try-catch, no momento exato que ocorrer a exceção ela será lançada e o método é interrompido automaticamente, equivalendo a um return. Ou seja, o método é interrompido sim!

No entanto, se seu objetivo é que o código lance a exceção mas que mesmo assim execute algum código em particular você faz assim:

static void metodo2() throws ArrayIndexOutOfBoundsException { 
   System.out.println("Início de m2.");  
   int[] array = new int[10];  
   try {  
      for (int i=1; i<=15;i++) {  
         array[i]=i;  // quando chegar no i = 10 vai lançar a exceção
         System.out.println(i);  
      }  
   } 
   finally {  
       // esse código vai ser executado mesmo o código acima lançando uma exceção.
       // se houvesse alguma chamada a return, ele também executaria antes de sair.
       // a única exceção é se a jvm for fechada, como "System.exit(0);"
       System.out.println("Fim de m2."); 
    }
}

ótima explicação Reilander…

porém eu queria entender como funciona essa questão de jogar o erro para o método que o chamou…
pois, msm não colocando o throws ArrayIndexOutOfBoundsException e colocando o try/catch no método1, o metodo1 mostra a msg de erro…

eu pensei que só era possível o método1 encontrar o erro(por meio de try/catch) do método2, se o throws estivesse no metodo2, que é o local real da falha…

apesar da boa explicação, fiquei com essas interrogações

Nesse caso específico não é preciso o throws, porque essa exeção não é checada, isto é, uma exceção que ocorre em tempo de execução geralmente por erro de programação (nesse caso o range maior que o esperado) ou por alguma falha no sistema que não seria possível quem chamou o método tratar essa exceção.

O que aconteceu é que a exceção não checada foi lançada e como ela estende de Exception, que é o tratamento que você dá no método 1, ela pára ali e o erro é mostrado.

Com ou sem throws, é como se todos os métodos que criamos implicitamente lançasse todas as exceções não checadas da API do Java ou nossas.

NullPointerException é um exemplo de exceção não checada. É como se em todo acesso a um membro de um objeto fosse feito esse teste antes de tentar acessá-lo com o ponto.
Exemplo, se no meu código eu tenho:

String nome = pessoa.getNome();

ao compilar ele seria traduzido para:

if (pessoa == null) {
   throws new NullPointerException();
}
String nome = pessoa.getNome();

opa,

o throw lança explicitamente um exceção. Vc pode usá-lo assim (mesmo que NÃO seja o ideal nesta situação):

try {
   for  (int i = 0; i < 15; i++) 
      if (i == 5) throw new arrayIndexOutOfBoundsException; //qdo o valor de  i = 5, uma exceção será lançada
      else array[i] = i;
   } catch (arrayIndexOutOfBoundsException e) {
      System.out.println(e);
   }

A cláusula throws diz que um método pode disparar um exceção. Por exemplo:

public void lancarExcecao() throws arrayIndexOutOfBoundsException {
        for  (int i = 0; i < 15; i++) 
          array[i] = i;

Na chamada do método lancarExcecao(), você deve usar o try/catch:

try { lancarExcecao(); } 
    catch(arrayIndexOutOfBoundsException e) { System.out.println(e); }

Quando você usa a clausula throws, o compilador obriga vc a usar o try/catch na chamada do método.

Espero ter ajudado!

Abraço!!!

Com estas explicações,

Entendi que existem as exceções não checadas (unchecked) e checadas pelo compilador (checked)

as exceções checadas devem ser tratadas, ou informando que ela pode ocorrer e mandando o chamador do método tratá-la por try/catch (colocando throws) ou sendo tratado no próprio método (por try/catch)

ainda existem o throw para lançar exceções específicas

Espero ter aprendido corretamente e muito obrigado pessoal…

abraços

OBS: se coloquei algo incorreto, favor me corrijam.

Sim, aprendeu correto.

Um detalhe é que se vc quiser criar sua própria exceção não checada, é só criar uma classe que herda de RunTimeException.