Современная обработка ошибок в php

Содержание:

std::invalid_argument
Обеспечение доступности данных об исключении при удаленном выполнении кодаEnsure that exception data is available when code executes remotely
Operator precedence
1 An Example First
Учебный пример, в котором есть примеры использования всех классов исключений:
Инструкция try/catch
The try…catch…finally Statement
How to Create Custom Exceptions
What Is an Exception?
- Exception Handling Control Flow
- Throwing an Exception
Использование блока finally
Поиск блока catch при обработке исключений
Что такое исключение?
- Поток управления обработкой исключений
- Выброс исключения
2 What is an Exception?
Определение классов исключенийDefining Exception Classes
4 Множественный перехват исключений

std::invalid_argument

Исключение определено в заголовочном файле <stdexcept>

Наследован от std::logic_error. Определяет исключение, которое должно быть брошено в случае неправильного аргумента.

Например, на MSDN приведён пример, когда в объект класса bitset из стандартной библиотеки

// invalid_arg.cpp  
// compile with: /EHsc /GR  
#include <bitset>  
#include <iostream>  
  
using namespace std;  
  
int main( )  
{  
   try   
   {  
      bitset< 32 > bitset( string( "11001010101100001b100101010110000") );  
   }  
   catch ( exception &e )   
   {  
      cerr << "Caught " << e.what( ) << endl;  
      cerr << "Type " << typeid( e ).name( ) << endl;  
   };  
}  
\* Output:   
Caught invalid bitset<N> char  
Type class std::invalid_argument  
*\

В данном примере передаётся неправильная строка, внутри которой имеется символ ‘b’, который будет ошибочным.

Обеспечение доступности данных об исключении при удаленном выполнении кодаEnsure that exception data is available when code executes remotely

Исключения и обработка исключений (руководство по программированию в c#)exceptions and exception handling (c# programming guide)

При создании пользовательских исключений следует обеспечить доступность метаданных исключений для удаленно исполняемого кода.When you create user-defined exceptions, ensure that the metadata for the exceptions is available to code that is executing remotely.

Например, для реализаций .NET, которые поддерживают домены приложений, могут возникать исключения для этих доменов.For example, on .NET implementations that support App Domains, exceptions may occur across App domains. Предположим, что домен приложения А создает домен приложения В, который выполняет код, вызывающий исключение.Suppose App Domain A creates App Domain B, which executes code that throws an exception. Чтобы домен приложения A правильно перехватил и обработал исключение, он должен найти сборку, которая содержит исключение, порожденное доменом приложения B. Если домен приложения B порождает исключение, содержащееся в сборке в его базовой папке приложения, но не в базовой папке приложения домена A, то домен приложения A не сможет найти исключение и среда CLR породит исключение FileNotFoundException.For App Domain A to properly catch and handle the exception, it must be able to find the assembly that contains the exception thrown by App Domain B. If App Domain B throws an exception that is contained in an assembly under its application base, but not under App Domain A’s application base, App Domain A will not be able to find the exception, and the common language runtime will throw a FileNotFoundException exception. Чтобы избежать такой ситуации, можно развернуть сборку, содержащую сведения об исключении, двумя способами:To avoid this situation, you can deploy the assembly that contains the exception information in two ways:

Поместите эту сборку в общую базу приложения, совместно используемую обоими доменами приложений.Put the assembly into a common application base shared by both app domains.

— или — or —
Если у этих доменов нет общей базы приложения, то подпишите сборку, содержащую сведения об исключении, строгим именем и разверните ее в глобальном кэше сборок.If the domains do not share a common application base, sign the assembly that contains the exception information with a strong name and deploy the assembly into the global assembly cache.

Operator precedence

How to convert string to int in c#?

If becomes an expression operator precedence becomes relevant. These examples are working today.

throw $this->createNotFoundException();
// Evaluated as
throw ($this->createNotFoundException());
// Instead of
(throw $this)->createNotFoundException();
 
throw static::createNotFoundException();
// Evaluated as
throw (static::createNotFoundException());
// Instead of
(throw static)::createNotFoundException();
 
throw $userIsAuthorized ? new ForbiddenException()  new UnauthorizedException();
// Evaluated as
throw ($userIsAuthorized ? new ForbiddenException()  new UnauthorizedException());
// Instead of
(throw $userIsAuthorized) ? new ForbiddenException()  new UnauthorizedException();
 
throw $maybeNullException ?? new Exception();
// Evaluated as
throw ($maybeNullException ?? new Exception());
// Instead of
(throw $maybeNullException) ?? new Exception();
 
throw $exception = new Exception();
// Evaluated as
throw ($exception = new Exception());
// Instead of
(throw $exception) = new Exception();
 
throw $exception ??= new Exception();
// Evaluated as
throw ($exception ??= new Exception());
// Instead of
(throw $exception) ??= new Exception();
 
throw $condition1 && $condition2 ? new Exception1()  new Exception2();
// Evaluated as
throw ($condition1 && $condition2 ? new Exception1()  new Exception2());
// Instead of
(throw $condition1) && $condition2 ? new Exception1()  new Exception2();

The common theme here is that everything after the keyword has a higher precedence. For this reason this RFC proposes to use the lowest operator precedence possible. All the current code, even if broken or strange, will continue behaving the same way. This isn’t a problem because generally should be the last operator you’re using as every expression after it wouldn’t be evaluated anyway.

The only downside of the low precedence is that a between two short-circuit operators would not be possible without parentheses:

$condition || throw new Exception('$condition must be truthy')
  && $condition2 || throw new Exception('$condition2 must be truthy');
// Evaluated as
$condition || (throw new Exception('$condition must be truthy') && $condition2 || (throw new Exception('$condition2 must be truthy')));
// Instead of
$condition || (throw new Exception('$condition must be truthy'))
  && $condition2 || (throw new Exception('$condition2 must be truthy'));

But I see little use for code like this.

1 An Example First

Ошибки и исключения

Before we begin with all the explanations, I would like to show an example first.

Let’s say you want to calculate the area of a circle, by the given radius. This function will do that:

It is very simple, however it does not check if the radius is a valid number. Now we are going to do that, and throw an exception if the radius is a negative number:

Let’s see what happens when we call it with a negative number:

The script crashes with the following message:

Since it was a fatal error, no more code execution happened after that. However you may not always want your scripts to stop whenever an Exception happens. Luckily, you can ‘catch’ them and handle them.

This time, let’s do it an array of radius values:

Now we get this output:

There are no more errors, and the script continues to run. That is how you catch exceptions.

Учебный пример, в котором есть примеры использования всех классов исключений:

class Example
{
  protected $author;  
  protected $month;  
  protected $goals = [];
  
  public function exceptions(int $a, int $b): int
  {
    $valid_a = ;
    if (!is_int($a)) {
      throw new InvalidArgumentException("a должно быть целочисленным!");
    }
    if ($a > 5 || !in_array($a, $valid_a, true)) {
      throw new DomainException("a не может быть больше 5");
    }
    
    $c = $this->getByIndex($a);
    if (!is_int($c)) {
      throw new RangeException("c посчитался неправильно!");
    } else {
      return $c;
    }      
  }
  
  private function getByIndex($a)
  {
    return ($a < 100) ? $a + 1 : null;
  }
  
  public function deleteNextGoal()
  {
    if (empty($this->goals)) {
      throw new UnderflowException("Нет цели, чтобы удалить!");
    } elseif (count($this->goals) > 100000) {
      throw new OverflowException("Система не может оперировать больше, чем 100000 целями одновременно!");
    } else {
      array_pop($this->goals);
    }
  }
  
  public function getGoalByIndex($i)
  {
    if (!isset ($this->goals)) {
      throw new OutOfBoundsException("Нет цели с индексом $i"); // легитимные значения известны только во время выполнения
    } else {
      return $this->goals;
    }
  }
  
  public function setPublicationMonth(int $month)
  {
    if ($month < 1 || $month > 12) {
      throw new OutOfRangeException("Месяц должен быть от 1 до 12!"); // легитимные значения известны заранее
    }
    $this->month = $month;
  }
  
  public function setAuthor($author)
  {
    if (mb_convert_case($author, MB_CASE_UPPER) !== $author) {
      throw new InvalidArgumentException("Все буквы имени автора должны быть заглавными");
    } else {
      if (mb_strlen($author) > 255) {
        throw new LengthException("Поле автор не должно быть больше 255 сиволов!");
      } else {
        $this->author = $author;
      }
    }
  }
  
  public function __call(string $name, array $args)
  {
    throw new BadMethodCallException("Метод Example>$name() не существует");
  }
}

Вот и всё. Думаю, материал буде полезен как новичкам, так и более продвинутым программистам. Я постарался систематизировать информацию об исключениях в одной статье.

Инструкция try/catch

C помощью инструкции исключение можно перехватить и обработать. Синтаксис инструкции :

try {
  // Исполняемый код
}
catch (e) {
  // При возникновении ошибки, делаем что-то
}

В блоке располагают код, в котором может возникнуть ошибка во время выполнения программы, а блок позволяет принять решение, что делать при возникновении ошибки. За ключевым словом следует идентификатор в круглых скобках. Этот идентификатор похож на параметр функции. При возникновении исключительной ситуации в блоке , этому параметру в качестве аргумента неявно передаётся объект , содержащий сведения об ошибке. Например, объект имеет свойство , содержащее сведения о типе ошибки и свойство содержащее описание ошибки. Имя параметра в круглых скобках может быть любым допустимым идентификатором:

try {
  alert(x);
  alert(2 + 2);  // Не будет выполнено
} catch (e) {
  alert(e.name + ": " + e.message);
}

Как видно из примера, при возникновении исключения выполнение кода в блоке прекращается и управление передаётся блоку . Если в блоке ошибка не возникает, то блок просто игнорируется:

try {
  alert("Код в блоке try");  // Код без ошибок
} catch(e) {
  alert("Блок catch игнорируется");
}

alert("Продолжается выполнение кода после инструкции try/catch...");

Без инструкции сообщения об ошибках автоматически выводятся в консоль браузера.

The try…catch…finally Statement

The statement can be used to catch exceptions. Code in the
block will always run regardless of whether an exception was caught. If
is present, the block is optional.

Syntax

try { code that can throw exceptions} catch(Exception $e) {
code that runs when an exception is caught} finally { code that
always runs regardless of whether an exception was caught}

Example

Show a message when an exception is thrown and then indicate that the process
has ended:

<?phpfunction divide($dividend, $divisor) { if($divisor
== 0) { throw new Exception(«Division by zero»);
} return $dividend / $divisor;}try { echo
divide(5, 0);} catch(Exception $e) { echo «Unable to
divide. «;} finally { echo «Process complete.»;}?>

Example

Output a string even if an exception was not caught:

<?phpfunction divide($dividend, $divisor) { if($divisor == 0)
{ throw new Exception(«Division by zero»); }
return $dividend / $divisor;}try { echo divide(5, 0);} finally { echo
«Process complete.»;}?>

How to Create Custom Exceptions

In this section, we’ll discuss how you can create custom exceptions in your applications. In fact, we’ll extend the example which we’ve just discussed in the previous section to demonstrate custom exceptions.

In the previous example, we threw the configuration exception using the default class. That’s perfectly fine as long as you just want to deal with the exception error message. However, sometimes you want to do a bit more based on the type of exception which is being thrown. That’s where custom exceptions are useful.

Let’s revisit the previous example, as shown in the following snippet.

Firstly, we’ve defined the class, which extends the default class. Now, it becomes our custom exception class, and we can use it when we want to throw the exception in our application.

Next, we’ve used the keyword to throw the exception if the config.php file doesn’t exist. The important difference lies in the block, though. As you can see, we’ve defined two blocks, and each block is used to catch the different type of exception.

The first one catches exceptions of the type. So, if an exception which is being thrown is of the type, this block will be executed. If the exception type doesn’t match any of the specific blocks, it will match the last one, which is there to catch all generic exception messages.

What Is an Exception?

PHP 5 introduced a new error model which allows you to throw and catch exceptions in your application—this is a better way of handling errors than what we had in older versions of PHP. All exceptions are instances of the base class , which we can extend to introduce our own custom exceptions.

It’s important to note here that exception handling is different than error handling. In error handling, we can use the function to set our custom error handling function so that whenever an error is triggered, it calls our custom error handling function. In that way, you can control errors. Generally, however, certain kinds of errors are unrecoverable and stop program execution.

On the other hand, exceptions are thrown deliberately by the code, and it’s expected that they’ll be caught at some point in your application. So we can say that exceptions are recoverable as opposed to certain errors which are unrecoverable. If an exception which is thrown is caught somewhere in your application, program execution continues from the point where the exception was caught. And an exception which is not caught anywhere in your application results in an error, thus halting program execution.

Exception Handling Control Flow

Let’s refer to the following diagram that shows the generic exception handling control flow.

Exceptions can be thrown and caught by using the PHP and blocks. You are responsible for throwing exceptions when something occurs which is not expected. Let’s quickly go through the basic exception handling flow, as shown in the following pseudo-code.

Most of the time, when you’re dealing with exceptions, you’ll end up using a pattern, as shown in the above snippet. You can also use the block along with the and blocks, but we’ll get back to that later in this article.

The block is the one to use where you suspect that your code may generate an exception. You should always wrap such code using and .

Throwing an Exception

An exception might be thrown by a function that you call, or you can use the keyword to throw an exception manually. For example, you might validate some input before performing any operation, and throw an exception if the data is not valid.

It’s important to note here that if you throw an exception but you haven’t defined the block which is supposed to handle that exception, it’ll result in a fatal error. So you need to make sure that you always define the block if you’re throwing exceptions in your application.

Once an exception is caught in the block, the object contains the error message which was thrown using the keyword. The variable in the above example is an instance of the class, so it has access to all methods of that class. In this block, you should define your own exception handling logic—what exactly you want to do with the error you catch.

In the next section, we’ll go through a real-world example to understand how exception handling works.

Использование блока finally

Иногда требуется определить кодовый блок, который будет выполняться после выхода из блока try/catch. В частности, исключительная ситуация может возникнуть
в связи с ошибкой, приводящей к преждевременному возврату из текущего метода.
Но в этом методе мог быть открыт файл, который нужно закрыть, или же установлено
сетевое соединение, требующее разрывания. Подобные ситуации нередки в программировании, и поэтому для их разрешения в C# предусмотрен удобный способ: воспользоваться блоком finally.

Использование блока finally гарантирует, что некоторый набор операторов будет выполняться всегда, независимо от того, возникло исключение (любого типа) или нет.

Для того чтобы указать кодовый блок, который должен выполняться после блока
try/catch, достаточно вставить блок finally в конце последовательности операторов try/catch. Ниже приведена общая форма совместного использования блоков try/catch и finally:

try {
// Блок кода, предназначенный для обработки ошибок.
}
catch (ExcepTypel exOb) {
// Обработчик исключения типа ExcepTypel
}
catch (ExcepType2 exOb) {
// Обработчик исключения типа ЕхсерType2.
}
finally {
// Код завершения обработки исключений.
}

Блок finally будет выполняться всякий раз, когда происходит выход из блока try/catch, независимо от причин, которые к этому привели. Это означает, что если блок
try завершается нормально или по причине исключения, то последним выполняется код, определяемый в блоке finally. Блок finally выполняется и в том случае, если
любой код в блоке try или в связанных с ним блоках catch приводит к возврату из метода.

Давайте рассмотрим пример:

C точки зрения синтаксиса блок finally следует после блока try, и формально блоки catch для этого не требуются. Следовательно, блок finally
можно ввести непосредственно после блока try, опустив блоки catch. В этом случае блок finally начнет выполняться сразу же после выхода из блока try, но исключения
обрабатываться не будут.

Поиск блока catch при обработке исключений

Последнее обновление: 23.10.2018

Если код, который вызывает исключение, не размещен в блоке try или помещен в конструкцию try..catch, которая не
содержит соответствующего блока catch для обработки возникшего исключения, то система производит поиск соответствующего обработчика исключения в стеке вызовов.

Например, рассмотрим следующую программу:

using System;

namespace HelloApp
{
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                TestClass.Method1();
            }
            catch (DivideByZeroException ex)
            {
                Console.WriteLine($"Catch в Main : {ex.Message}");
            }
            finally
            {
                Console.WriteLine("Блок finally в Main");
            }
			Console.WriteLine("Конец метода Main");
            Console.Read();
        }
    }
    class TestClass
    {
        public static void Method1()
        {
            try
            {
                Method2();
            }
            catch (IndexOutOfRangeException ex)
            {
                Console.WriteLine($"Catch в Method1 : {ex.Message}");
            }
            finally
            {
                Console.WriteLine("Блок finally в Method1");
            }
			Console.WriteLine("Конец метода Method1");
        }
        static void Method2()
        {
            try
            {
                int x = 8;
                int y = x / 0;
            }
            finally
            {
                Console.WriteLine("Блок finally в Method2");
            }
			Console.WriteLine("Конец метода Method2");
        }
    }
}

В данном случае стек вызовов выглядит следующим образом: метод Main вызывает метод Method1, который, в свою очередь, вызывает метод Method2. И в методе
Method2 генерируется исключение DivideByZeroException. Визуально стек вызовов можно представить следующим образом:

Внизу стека метод Main, с которого началось выполнение, и на самом верху метод Method2.

Что будет происходить в данном случае при генерации исключения?

Метод Main вызывает метод Method1, а тот вызывает метод Method2, в котором генерируется исключение DivideByZeroException.
Система видит, что код, который вызывал исключение, помещен в конструкцию try..catch
```
try
{
	int x = 8;
	int y = x / 0;
}
finally
{
	Console.WriteLine("Блок finally в Method2");
}
```
Система ищет в этой конструкции блок catch, который обрабатывает исключение DivideByZeroException. Однако такого блока catch нет.
Система опускается в стеке вызовов в метод Method1, который вызывал Method2. Здесь вызов Method2 помещен в
конструкцию try..catch
```
try
{
	Method2();
}
catch (IndexOutOfRangeException ex)
{
	Console.WriteLine($"Catch в Method1 : {ex.Message}");
}
finally
{
	Console.WriteLine("Блок finally в Method1");
}
```
Система также ищет в этой конструкции блок catch, который обрабатывает исключение DivideByZeroException. Однако
здесь также подобный блок catch отсутствует.
Система далее опускается в стеке вызовов в метод Main, который вызывал Method1. Здесь вызов Method1 помещен в
конструкцию try..catch
```
try
{
	TestClass.Method1();
}
catch (DivideByZeroException ex)
{
	Console.WriteLine($"Catch в Main : {ex.Message}");
}
finally
{
	Console.WriteLine("Блок finally в Main");
}
```
Система снова ищет в этой конструкции блок catch, который обрабатывает исключение DivideByZeroException. И в
данном случае ткой блок найден.
Система наконец нашла нужный блок catch в методе Main, для обработки исключения, которое возникло
в методе Method2 — то есть к начальному методу, где непосредственно возникло исключение. Но пока данный блок catch НЕ выполняется. Система поднимается обратно по стеку вызовов в самый верх в метод
Method2 и выполняет в нем блок finally:
```
finally
{
	Console.WriteLine("Блок finally в Method2");
}
```
Далее система возвращается по стеку вызовов вниз в метод Method1 и выполняет в нем блок finally:
```
finally
{
	Console.WriteLine("Блок finally в Method1");
}
```
Затем система переходит по стеку вызовов вниз в метод Main и выполняет в нем найденный блок catch и последующий блок finally:
```
catch (DivideByZeroException ex)
{
	Console.WriteLine($"Catch в Main : {ex.Message}");
}
finally
{
	Console.WriteLine("Блок finally в Main");
}
```
Далее выполняется код, который идет в методе Main после конструкции try..catch:
```
Console.WriteLine("Конец метода Main");
```
Стоит отметить, что код, который идет после конструкции try…catch в методах Method1 и Method2, не выполняется, потому что обработчик исключения найден именно в методе Main.

Консольный вывод программы:

Блок finally в Method2
Блок finally в Method1
Catch в Main: Попытка деления на нуль.
Блок finally в Main
Конец метода Main

НазадВперед

Что такое исключение?

В PHP 5 появилась новая модель ошибок, которая позволяет вам кидать и ловить исключения в вашем приложении — это лучший способ обработки ошибок, чем то, что мы имели в более старых версиях PHP. Все исключения являются экземплярами базового класса , который мы можем расширить, чтобы ввести наши собственные пользовательские исключения.

Здесь важно отметить, что обработка исключений отличается от обработки ошибок. При обработке ошибок мы можем использовать функцию для установки нашей настраиваемой функции обработки ошибок, чтобы всякий раз, когда срабатывает ошибка, она вызывала нашу функцию обработки ошибок

Таким образом, вы можете управлять ошибками. Однако, как правило, некоторые виды ошибок не восстанавливаются и прекращают выполнение программы.

С другой стороны, исключения — это что-то, что умышленно вызывает код, и ожидается, что он будет пойман в какой-то момент вашего приложения. Таким образом, мы можем сказать, что исключения восстанавливаются, а не определенные ошибки, которые не подлежат восстановлению. Если исключение, которое выбрасывается, попадает где-то в ваше приложение, выполнение программы продолжается с момента, когда исключение было поймано. А исключение, которое не попадает нигде в ваше приложение, приводит к ошибке, которое останавливает выполнение программы.

Поток управления обработкой исключений

Давайте рассмотрим следующую диаграмму, которая показывает общий поток управления обработкой исключений.

Исключения могут быть выброшены и пойманы с помощью блоков и . Вы несете ответственность за выброс исключений, если что-то произойдет, чего не ожидается. Давайте быстро рассмотрим основной поток обработки исключений, как показано в следующем псевдокоде.

В большинстве случаев, когда вы имеете дело с исключениями, вы в конечном итоге используете шаблон, как показано в приведенном выше фрагменте. Вы также можете использовать блок вместе с блоками и , но мы вернемся к этому позже в этой статье.

Блок — тот, который используется, когда вы подозреваете, что ваш код может генерировать исключение. Вы всегда должны обертывать такой код, используя и .

Выброс исключения

Исключение может быть вызвано функцией, которую вы вызываете, или вы можете использовать ключевое слово для выбрасывания исключения вручную. Например, вы можете проверить некоторый ввод перед выполнением любой операции и выбросить исключение, если данные недействительны.

Здесь важно отметить, что если вы выбросите исключение, но вы не определили блок , который должен обрабатывать это исключение, это приведет к фатальной ошибке. Поэтому вам нужно убедиться, что вы всегда определяете блок , если вы бросаете исключения в своем приложении

Когда исключение попадает в блок , объект содержит сообщение об ошибке, которое было выбрано с использованием ключевого слова . Переменная в приведенном выше примере является экземпляром класса , поэтому она имеет доступ ко всем методам этого класса. В этом блоке вы должны определить свою собственную логику обработки исключений — что именно вы хотите сделать с ошибкой, которую вы поймаете.

В следующем разделе мы рассмотрим пример из реального мира, чтобы понять, как работает обработка исключений.

2 What is an Exception?

Exceptions have been around in other object oriented programming languages for quite some time. It was first adopted in PHP with version 5.

By definition an Exception is ‘thrown’, when an exceptional event happens. This could be as simple as a ‘division by zero’, or any other kind of invalid situation.

This may sound similar to other basic errors that you have already seen many times. But Exceptions have a different kind of mechanism.

Exceptions are actually objects and you have the option to ‘catch’ them and execute certain code. This is done by using ‘try-catch’ blocks:

We can enclose any code within a ‘try’ block. The following ‘catch’ block is used for catching any exception that might have been thrown from within the try block. The catch block never gets executed if there were no exceptions. Also, once an exception happens, the script immediately jumps to the catch block, without executing any further code.

Further in the article we will have more examples that should demonstrate the power and flexibility of using exceptions instead of simple error messages.

Определение классов исключенийDefining Exception Classes

Программы могут вызывать предопределенный класс исключений в пространстве имен System (кроме указанных ранее случаев) или создавать собственные классы исключений путем наследования от Exception.Programs can throw a predefined exception class in the System namespace (except where previously noted), or create their own exception classes by deriving from Exception. Производные классы должны определять по крайней мере четыре конструктора: один конструктор без параметров, один конструктор, задающий свойство сообщения, и еще один, задающий свойства Message и InnerException.The derived classes should define at least four constructors: one parameterless constructor, one that sets the message property, and one that sets both the Message and InnerException properties. Четвертый конструктор служит для сериализации исключения.The fourth constructor is used to serialize the exception. Новые классы исключений должны быть сериализуемыми.New exception classes should be serializable. Пример:For example:

Новые свойства следует добавлять к классу исключений только в том случае, если данные в них могут помочь в разрешении исключения.New properties should only be added to the exception class when the data they provide is useful to resolving the exception. При добавлении новых свойств в производный класс исключений метод необходимо переопределить так, чтобы он возвращал добавленные сведения.If new properties are added to the derived exception class, should be overridden to return the added information.

4 Множественный перехват исключений

Программисты очень не любят дублирование кода. Даже придумали такой принцип разработки — DRY: Don’t Repeat Yourself. Однако при обработке исключений часто возникают ситуации, когда после блока следует несколько блоков с одинаковым кодом.

Или может быть, например, 3 -блока с одним кодом и еще 2 -блока с другим. Стандартная в общем-то ситуация, когда у вас в проекте ответственно относятся к обработке исключений.

Начиная с 7-й версии, в язык Java добавили возможность указать несколько типов исключений в одном блоке . Выглядит это примерно так:

Блоков может быть сколько угодно. Однако в одном блоке нельзя указать исключения, которые наследуются друг от друга. Т.е. нельзя написать catch ( | e), т.к. класс унаследован от .