Bisakah saya menangkap beberapa pengecualian Java dalam klausa tangkapan yang sama?

Di Jawa, saya ingin melakukan sesuatu seperti ini:

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

...dari pada:

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

Apakah ada cara untuk melakukan ini?

Ini telah dimungkinkan sejak Java 7 . Sintaks untuk blok multi-tangkap adalah:

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

Namun, ingatlah bahwa jika semua pengecualian milik hierarki kelas yang sama, Anda bisa menangkap tipe pengecualian dasar itu.

Perhatikan juga bahwa Anda tidak dapat menangkap ExceptionA dan ExceptionB di blok yang sama jika ExceptionB diwarisi, baik secara langsung maupun tidak langsung, dari ExceptionA. Kompiler akan mengeluh:

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

Tidak persis sebelum Java 7 tetapi, saya akan melakukan sesuatu seperti ini:

Java 6 dan sebelumnya

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();
}

Dalam Java 7 Anda dapat mendefinisikan beberapa klausa tangkapan seperti:

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

Jika ada hierarki pengecualian, Anda bisa menggunakan kelas dasar untuk menangkap semua subkelas pengecualian. Dalam kasus degenerasi Anda dapat menangkap semua pengecualian Java dengan:

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

Dalam kasus yang lebih umum jika RepositoryException adalah kelas dasar dan PathNotFoundException adalah kelas turunan maka:

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

Kode di atas akan menangkap RepositoryException dan PathNotFoundException untuk satu jenis penanganan pengecualian dan semua pengecualian lainnya disatukan. Sejak Java 7, sesuai jawaban @ OscarRyz di atas:

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

Tidak, satu per pelanggan.

Anda dapat menangkap superclass, seperti java.lang.Exception, selama Anda melakukan tindakan yang sama dalam semua kasus.

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

Tapi itu mungkin bukan praktik terbaik. Anda seharusnya hanya menangkap pengecualian ketika Anda memiliki strategi untuk benar-benar menanganinya - dan logging dan rethrowing bukan "menanganinya". Jika Anda tidak memiliki tindakan korektif, lebih baik menambahkannya ke tanda tangan metode dan membiarkannya menggelembung ke seseorang yang dapat menangani situasi tersebut.

Alternatif yang lebih bersih (tetapi kurang bertele-tele, dan mungkin tidak seperti pilihan) untuk jawaban user454322 di Java 6 (yaitu, Android) adalah untuk menangkap semua Exceptiondan melempar kembali RuntimeException. Ini tidak akan berhasil jika Anda berencana untuk menangkap jenis pengecualian lain di atas tumpukan (kecuali Anda juga melemparkannya kembali), tetapi secara efektif akan menangkap semua pengecualian yang dicentang .

Contohnya:

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
    } 
}

Yang sedang berkata, untuk verbosity, mungkin lebih baik untuk mengatur boolean atau variabel lain dan berdasarkan itu jalankan beberapa kode setelah blok try-catch.

Di pra-7 bagaimana dengan:

  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.
  }

Iya. Inilah cara menggunakan pemisah pipa (|),

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

Untuk kotlin, itu tidak mungkin untuk saat ini tetapi mereka telah mempertimbangkan untuk menambahkannya: Sumber
Tapi untuk saat ini, hanya sedikit trik:

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

Tangkap pengecualian yang kebetulan menjadi kelas induk dalam hierarki pengecualian. Ini tentu saja, praktik buruk . Dalam kasus Anda, pengecualian orang tua yang umum terjadi adalah kelas Pengecualian, dan menangkap setiap pengecualian yang merupakan contoh Pengecualian, memang praktik yang buruk - pengecualian seperti NullPointerException biasanya kesalahan pemrograman dan biasanya harus diselesaikan dengan memeriksa nilai nol.