Posso capturar várias exceções de Java na mesma cláusula de captura?

Em Java, eu quero fazer algo assim:

try {
    ...     
} catch (/* code to catch IllegalArgumentException, SecurityException, 
            IllegalAccessException, and NoSuchFieldException at the same time */) {
   someCode();
}

...ao invés de:

try {
    ...     
} catch (IllegalArgumentException e) {
    someCode();
} catch (SecurityException e) {
    someCode();
} catch (IllegalAccessException e) {
    someCode();
} catch (NoSuchFieldException e) {
    someCode();
}

Há alguma maneira de fazer isso?

Isso é possível desde o Java 7 . A sintaxe para um bloco de captura múltipla é:

try { 
  ...
} catch (IOException | SQLException ex) { 
  ...
}

Lembre-se, porém, de que se todas as exceções pertencerem à mesma hierarquia de classes, você poderá simplesmente capturar esse tipo de exceção base.

Observe também que você não pode capturar ExceptionA e ExceptionB no mesmo bloco se ExceptionB for herdado, direta ou indiretamente, de ExceptionA. O compilador irá reclamar:

Alternatives in a multi-catch statement cannot be related by subclassing
  Alternative ExceptionB is a subclass of alternative ExceptionA

Não exatamente antes do Java 7, mas eu faria algo assim:

Java 6 e anterior

try {
  //.....
} catch (Exception exc) {
  if (exc instanceof IllegalArgumentException || exc instanceof SecurityException || 
     exc instanceof IllegalAccessException || exc instanceof NoSuchFieldException ) {

     someCode();

  } else if (exc instanceof RuntimeException) {
     throw (RuntimeException) exc;     

  } else {
    throw new RuntimeException(exc);
  }

}

Java 7

try {
  //.....
} catch ( IllegalArgumentException | SecurityException |
         IllegalAccessException |NoSuchFieldException exc) {
  someCode();
}

No Java 7, você pode definir várias cláusulas de captura, como:

catch (IllegalArgumentException | SecurityException e)
{
    ...
}

Se houver uma hierarquia de exceções, você poderá usar a classe base para capturar todas as subclasses de exceções. No caso degenerado, você pode capturar todas as exceções de Java com:

try {
   ...
} catch (Exception e) {
   someCode();
}

Em um caso mais comum, se RepositoryException for a classe base e PathNotFoundException for uma classe derivada, então:

try {
   ...
} catch (RepositoryException re) {
   someCode();
} catch (Exception e) {
   someCode();
}

O código acima capturará RepositoryException e PathNotFoundException para um tipo de tratamento de exceção e todas as outras exceções são agrupadas. Desde o Java 7, conforme a resposta de @ OscarRyz acima:

try { 
  ...
} catch( IOException | SQLException ex ) { 
  ...
}

Não, um por cliente.

Você pode capturar uma superclasse, como java.lang.Exception, desde que execute a mesma ação em todos os casos.

try {
    // some code
} catch(Exception e) { //All exceptions are caught here as all are inheriting java.lang.Exception
    e.printStackTrace();
}

Mas essa pode não ser a melhor prática. Você só deve capturar uma exceção quando tiver uma estratégia para lidar com isso de verdade - e o registro e a repetição não estão "lidando com isso". Se você não tiver uma ação corretiva, é melhor adicioná-la à assinatura do método e deixar que ela borbulhe para alguém que possa lidar com a situação.

Uma alternativa mais limpa (mas menos detalhada e talvez não a preferida) à resposta do usuário454322 no Java 6 (ou seja, Android) seria pegar todos os se Exceptionvoltar a jogar RuntimeException. Isso não funcionaria se você estiver planejando capturar outros tipos de exceções além da pilha (a menos que você também as jogue novamente), mas efetivamente capturará todas as exceções verificadas .

Por exemplo:

try {
    // CODE THAT THROWS EXCEPTION
} catch (Exception e) {
    if (e instanceof RuntimeException) {
        // this exception was not expected, so re-throw it
        throw e;
    } else {
        // YOUR CODE FOR ALL CHECKED EXCEPTIONS
    } 
}

Dito isto, para maior detalhamento, pode ser melhor definir uma variável booleana ou outra variável e, com base nisso, executar algum código após o bloco try-catch.

No pré-7, que tal:

  Boolean   caught = true;
  Exception e;
  try {
     ...
     caught = false;
  } catch (TransformerException te) {
     e = te;
  } catch (SocketException se) {
     e = se;
  } catch (IOException ie) {
     e = ie;
  }
  if (caught) {
     someCode(); // You can reference Exception e here.
  }

Sim. Aqui está o caminho usando o separador pipe (|),

try
{
    .......
}    
catch
{
    catch(IllegalArgumentException | SecurityException | IllegalAccessException | NoSuchFieldException e)
}

Para o kotlin, não é possível por enquanto, mas eles consideraram adicioná-lo: Source
Mas, por enquanto, apenas um pequeno truque:

try {
    // code
} catch(ex:Exception) {
    when(ex) {
        is SomeException,
        is AnotherException -> {
            // handle
        }
        else -> throw ex
    }
}

Capture a exceção que é uma classe pai na hierarquia de exceções. Naturalmente, isso é uma má prática . No seu caso, a exceção pai comum passa a ser a classe Exception, e capturar qualquer exceção que seja uma instância de Exception é realmente uma prática ruim - exceções como NullPointerException geralmente são erros de programação e geralmente devem ser resolvidas verificando-se valores nulos.