Ошибки java список

Перечень наиболее часто встречающихся исключений (исключительных ситуаций, ошибок) в языке программирования java с расшифровкой их значения.

Перечень наиболее часто встречающихся исключений (исключительных ситуаций, ошибок) в языке программирования java с расшифровкой их значения.

Содержание

  1. ArithmeticException 
  2. ArrayIndexOutOfBoundsException 
  3. ArrayStoreException 
  4. ClassCastException 
  5. ConcurrentModificationException 
  6. EmptyStackException
  7. IllegalArgumentException 
  8. IllegalMonitorStateException 
  9. IllegalStateException 
  10. IllegalThreadStateException 
  11. IndexOutOfBoundsException 
  12. MissingResourceException 
  13. NegativeArraySizeException 
  14. NoSuchElementException 
  15. NullPointerException 
  16. NumberFormatException
  17. SecurityException
  18. StringIndexOutOfBoundsException
  19. UndeclaredThrowableException
  20. UnsupportedOperationException 

ArithmeticException 

Возникла исключительная ситуация, связанная с ошибкой при выполнении арифметического вычисления (например, с попыткой целочисленного деления на нуль). Класс ArithmeticalException унаследован от RuntimeException.

ArrayIndexOutOfBoundsException 

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

ArrayStoreException 

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

Класс ArrayStoreException унаследован от RuntimeException.

ClassCastException 

Выполнена неверная операция преобразования типов (ошибка приведения типов).

Класс ClassCastException унаследован от RuntimeException.

ConcurrentModificationException 

Осуществлена попытка изменения объекта конкурирующим потоком вычислений (thread) с нарушением контракта класса (тип определен в пакете jav.util).

Также исключение может происходить при работе с коллекциями при обычной однопоточной работе. ConcurrentModificationException возникает когда коллекция модифицируется «одновременно» с проходом по коллекции итератором любыми средствами кроме самого итератора.

Класс ConcurrentModificationException унаследован от RuntimeException.

EmptyStackException

Возникает при попытке извлечения объекта из пустого стека. Тип обладает только конструктором без параметров, поскольку причина ситуации очевидна без дополнительных разъяснений (тип определен в пакете java.util). 

Класс EmptyStackExceptionунаследован от RuntimeException.

IllegalArgumentException 

Методу передано неверное значение аргумента (например, отрицательное, когда метод предполагает задание положительных значений).

Класс IllegalArgumentExceptionунаследован от RuntimeException.

IllegalMonitorStateException 

Выполнено обращение к методу wait, notifyAll или notify объекта, когда текущий поток вычислений не обладает блокировкой (lock) этого объекта.

Класс IllegalMonitorStateException унаследован от RuntimeException.

IllegalStateException 

Предпринята попытка выполнения операции в то время, когда объект не находится в соответствующем состоянии (например при регистрации или удалении ловушки события закрытия исполняющей системы (shutdown hook) после начала процедуры закрытия).

Класс IllegalStateExceptionунаследован от RuntimeException.

IllegalThreadStateException 

Предпринята попытка выполнения операции в то время, когда объект потока вычислений не находится в соответствующем состоянии (например, вызван метод start для потока, который уже приступил к работе).

Класс IllegalThreadStateException унаследован от IllegalArgumentException

IndexOutOfBoundsException 

Задано значение индекса массива или содержимого строки типа String, не принадлежащее допустимому диапазону.

Класс IndexOutOfBoundsException унаследован от RuntimeException

MissingResourceException 

Не найден требуемый ресурс или пакет ресурсов (resource bundle). Единственный конструктор типа предусматривает задание трех аргументов: строки описательного сообщения, наименования класса ресурсов и объекта ключа, отвечающего отсутствующему ресурсу. Для получения строк наименования класса и ключа применяются методы detClassName и getKey соответственно (тип определен в пакете java.util).

Класс MissingResourceExceptionунаследован от RuntimeException.

NegativeArraySizeException 

Предпринята попытка создания массива с размером, значение которого задано отрицательным числом.

Класс NegativeArraySizeException унаследован от RuntimeException.

NoSuchElementException 

Операция поиска элемента в объекте одного из контейнерных классов завершилась неудачей (тип определен в пакете java.util).

Класс NoSuchElementException унаследован от RuntimeException.

NullPointerException 

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

Класс NullPointerException унаследован от RuntimeException.

NumberFormatException

Строка, которая, как предполагалось должна содержать представление числа, не отвечает этому требованию. Исключение выбрасывается такими методами, как, например, Integer.parseInt.

Класс NumberFormatException унаследован от IllegalArgumentException.

SecurityException

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

Класс SecurityException унаследован от RuntimeException.

StringIndexOutOfBoundsException

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

Класс StringIndexOutOfBoundsException унаследован от IndexOutOfBoundsException.

UndeclaredThrowableException

Выбрасывается при обращении к методу целевого объекта посредством объекта рефлективного класса Proxy, если метод invoke объекта InvocationHandler генерирует объявляемое исключение, которое не допускает присваивания ни одному из типов исключений, упомянутых в предложении throws метода целевого объекта. Рассматриваемое исключение содержит ссылку на исключение, генерируемое методом invoke, которое может быть получено с помощью метода getUndeclaredThrowable. Класс исключений UndeclaredThrowableException поддерживает два конструктора: оба принимают в качестве параметров ссылку на объект Throwable, а один из них, помимо того, строку описания (тип определен в пакете java.lang.reflect).

Класс UndeclaredThrowableException унаследован от RuntimeException.

UnsupportedOperationException 

Предпринята попытка выполнения операции над объектом, который ее не поддерживает (например, модификация объекта, обозначенного признаком «только для чтения»). используется также классами коллекций из состава пакета java.util как реакция на вызов методов производного класса, реализация которых не обязательна.

Класс UnsupportedOperationException унаследован от RuntimeException.

Смотрите также: Методы обработки исключений в java

Источник

List of Java Exceptions

All public exceptions and errors in the Java API, grouped by package.

✔: Checked exception
<version>: Since version

Package java­.lang

  • Throwable ✔

    • Exception ✔

      • Clone­Not­Supported­Exception ✔
      • Interrupted­Exception ✔
      • Reflective­Operation­Exception ✔

        • Class­Not­Found­Exception ✔
        • Illegal­Access­Exception ✔
        • Instantiation­Exception ✔
        • No­Such­Field­Exception ✔
        • No­Such­Method­Exception ✔
      • Runtime­Exception

        • Arithmetic­Exception
        • Array­Store­Exception
        • Class­Cast­Exception
        • Enum­Constant­Not­Present­Exception
        • Illegal­Argument­Exception

          • Illegal­Thread­State­Exception
          • Number­Format­Exception
        • Illegal­Caller­Exception 9
        • Illegal­Monitor­State­Exception
        • Illegal­State­Exception
        • Index­Out­Of­Bounds­Exception

          • Array­Index­Out­Of­Bounds­Exception
          • String­Index­Out­Of­Bounds­Exception
        • Layer­Instantiation­Exception 9
        • Negative­Array­Size­Exception
        • Null­Pointer­Exception
        • Security­Exception
        • Type­Not­Present­Exception
        • Unsupported­Operation­Exception
    • Error

      • Assertion­Error
      • Linkage­Error

        • Bootstrap­Method­Error
        • Class­Circularity­Error
        • Class­Format­Error

          • Unsupported­Class­Version­Error
        • Exception­In­Initializer­Error
        • Incompatible­Class­Change­Error

          • Abstract­Method­Error
          • Illegal­Access­Error
          • Instantiation­Error
          • No­Such­Field­Error
          • No­Such­Method­Error
        • No­Class­Def­Found­Error
        • Unsatisfied­Link­Error
        • Verify­Error
      • Thread­Death
      • Virtual­Machine­Error

        • Internal­Error
        • Out­Of­Memory­Error
        • Stack­Overflow­Error
        • Unknown­Error

Package java­.util

  • Service­Configuration­Error
  • Invalid­Properties­Format­Exception ✔
  • Concurrent­Modification­Exception
  • Empty­Stack­Exception
  • Illegal­Format­Exception

    • Duplicate­Format­Flags­Exception
    • Format­Flags­Conversion­Mismatch­Exception
    • Illegal­Format­Code­Point­Exception
    • Illegal­Format­Conversion­Exception
    • Illegal­Format­Flags­Exception
    • Illegal­Format­Precision­Exception
    • Illegal­Format­Width­Exception
    • Missing­Format­Argument­Exception
    • Missing­Format­Width­Exception
    • Unknown­Format­Conversion­Exception
    • Unknown­Format­Flags­Exception
  • Formatter­Closed­Exception
  • Illformed­Locale­Exception
  • Missing­Resource­Exception
  • No­Such­Element­Exception

    • Input­Mismatch­Exception
  • Too­Many­Listeners­Exception ✔

Package java­.io

  • I­O­Error
  • I­O­Exception ✔

    • Char­Conversion­Exception ✔
    • E­O­F­Exception ✔
    • File­Not­Found­Exception ✔
    • Interrupted­I­O­Exception ✔
    • Object­Stream­Exception ✔

      • Invalid­Class­Exception ✔
      • Invalid­Object­Exception ✔
      • Not­Active­Exception ✔
      • Not­Serializable­Exception ✔
      • Optional­Data­Exception ✔
      • Stream­Corrupted­Exception ✔
      • Write­Aborted­Exception ✔
    • Sync­Failed­Exception ✔
    • U­T­F­Data­Format­Exception ✔
    • Unsupported­Encoding­Exception ✔
  • Unchecked­I­O­Exception 1.8

Package java­.awt

  • A­W­T­Error
  • A­W­T­Exception ✔
  • Font­Format­Exception ✔
  • Illegal­Component­State­Exception
  • Headless­Exception

Package java­.awt­.color

  • C­M­M­Exception
  • Profile­Data­Exception

Package java­.awt­.datatransfer

  • Mime­Type­Parse­Exception ✔
  • Unsupported­Flavor­Exception ✔

Package java­.awt­.dnd

  • Invalid­Dn­D­Operation­Exception

Package java­.awt­.geom

  • Noninvertible­Transform­Exception ✔
  • Illegal­Path­State­Exception

Package java­.awt­.image

  • Imaging­Op­Exception
  • Raster­Format­Exception

Package java­.awt­.print

  • Printer­Exception ✔

    • Printer­Abort­Exception ✔
    • Printer­I­O­Exception ✔

Package java­.beans

  • Introspection­Exception ✔
  • Property­Veto­Exception ✔

Package java­.lang­.annotation

  • Annotation­Format­Error
  • Annotation­Type­Mismatch­Exception
  • Incomplete­Annotation­Exception

Package java­.lang­.instrument

  • Illegal­Class­Format­Exception ✔
  • Unmodifiable­Module­Exception 9
  • Unmodifiable­Class­Exception ✔

Package java­.lang­.invoke

  • Lambda­Conversion­Exception ✔, 1.8
  • Wrong­Method­Type­Exception
  • String­Concat­Exception ✔, 9

Package java­.lang­.module

  • Find­Exception 9
  • Invalid­Module­Descriptor­Exception 9
  • Resolution­Exception 9

Package java­.lang­.reflect

  • Generic­Signature­Format­Error
  • Invocation­Target­Exception ✔
  • Inaccessible­Object­Exception 9
  • Malformed­Parameterized­Type­Exception
  • Malformed­Parameters­Exception 1.8
  • Undeclared­Throwable­Exception

Package java­.net

  • Http­Retry­Exception ✔
  • Socket­Timeout­Exception ✔
  • Malformed­U­R­L­Exception ✔
  • Protocol­Exception ✔
  • Socket­Exception ✔

    • Bind­Exception ✔
    • Connect­Exception ✔
    • No­Route­To­Host­Exception ✔
    • Port­Unreachable­Exception ✔
  • Unknown­Host­Exception ✔
  • Unknown­Service­Exception ✔
  • U­R­I­Syntax­Exception ✔

Package java­.net­.http

  • Http­Timeout­Exception ✔, 11

    • Http­Connect­Timeout­Exception ✔, 11
  • Web­Socket­Handshake­Exception ✔, 11

Package java­.nio

  • Buffer­Overflow­Exception
  • Buffer­Underflow­Exception
  • Invalid­Mark­Exception
  • Read­Only­Buffer­Exception

Package java­.nio­.channels

  • Closed­Channel­Exception ✔

    • Asynchronous­Close­Exception ✔

      • Closed­By­Interrupt­Exception ✔
  • File­Lock­Interruption­Exception ✔
  • Interrupted­By­Timeout­Exception ✔
  • Illegal­Channel­Group­Exception
  • Illegal­Selector­Exception
  • Unresolved­Address­Exception
  • Unsupported­Address­Type­Exception
  • Accept­Pending­Exception
  • Already­Bound­Exception
  • Already­Connected­Exception
  • Cancelled­Key­Exception
  • Closed­Selector­Exception
  • Connection­Pending­Exception
  • Illegal­Blocking­Mode­Exception
  • No­Connection­Pending­Exception
  • Non­Readable­Channel­Exception
  • Non­Writable­Channel­Exception
  • Not­Yet­Bound­Exception
  • Not­Yet­Connected­Exception
  • Overlapping­File­Lock­Exception
  • Read­Pending­Exception
  • Shutdown­Channel­Group­Exception
  • Write­Pending­Exception

Package java­.nio­.charset

  • Coder­Malfunction­Error
  • Character­Coding­Exception ✔

    • Malformed­Input­Exception ✔
    • Unmappable­Character­Exception ✔
  • Illegal­Charset­Name­Exception
  • Unsupported­Charset­Exception

Package java­.nio­.file

  • File­System­Exception ✔

    • Access­Denied­Exception ✔
    • Atomic­Move­Not­Supported­Exception ✔
    • Directory­Not­Empty­Exception ✔
    • File­Already­Exists­Exception ✔
    • File­System­Loop­Exception ✔
    • No­Such­File­Exception ✔
    • Not­Directory­Exception ✔
    • Not­Link­Exception ✔
  • Directory­Iterator­Exception
  • File­System­Already­Exists­Exception
  • File­System­Not­Found­Exception
  • Invalid­Path­Exception
  • Provider­Mismatch­Exception
  • Closed­Directory­Stream­Exception
  • Closed­File­System­Exception
  • Closed­Watch­Service­Exception
  • Provider­Not­Found­Exception
  • Read­Only­File­System­Exception

Package java­.nio­.file­.attribute

  • User­Principal­Not­Found­Exception ✔

Package java­.rmi

  • Already­Bound­Exception ✔
  • Remote­Exception ✔

    • Access­Exception ✔
    • Connect­Exception ✔
    • Connect­I­O­Exception ✔
    • Marshal­Exception ✔
    • No­Such­Object­Exception ✔
    • Server­Error ✔
    • Server­Exception ✔
    • Server­Runtime­Exception ✔
    • Stub­Not­Found­Exception ✔
    • Unexpected­Exception ✔
    • Unknown­Host­Exception ✔
    • Unmarshal­Exception ✔
  • Not­Bound­Exception ✔
  • R­M­I­Security­Exception

Package java­.rmi­.activation

  • Activation­Exception ✔

    • Unknown­Group­Exception ✔
    • Unknown­Object­Exception ✔
  • Activate­Failed­Exception ✔

Package java­.rmi­.server

  • Server­Clone­Exception ✔
  • Export­Exception ✔

    • Socket­Security­Exception ✔
  • Skeleton­Mismatch­Exception ✔
  • Skeleton­Not­Found­Exception ✔
  • Server­Not­Active­Exception ✔

Package java­.security

  • General­Security­Exception ✔

    • Digest­Exception ✔
    • Invalid­Algorithm­Parameter­Exception ✔
    • Key­Exception ✔

      • Invalid­Key­Exception ✔
      • Key­Management­Exception ✔
    • Key­Store­Exception ✔
    • No­Such­Algorithm­Exception ✔
    • No­Such­Provider­Exception ✔
    • Signature­Exception ✔
    • Unrecoverable­Entry­Exception ✔

      • Unrecoverable­Key­Exception ✔
  • Privileged­Action­Exception ✔
  • Invalid­Parameter­Exception
  • Provider­Exception
  • Access­Control­Exception

Package java­.security­.acl

  • Acl­Not­Found­Exception ✔
  • Last­Owner­Exception ✔
  • Not­Owner­Exception ✔

Package java­.security­.cert

  • Certificate­Exception ✔

    • Certificate­Encoding­Exception ✔
    • Certificate­Expired­Exception ✔
    • Certificate­Not­Yet­Valid­Exception ✔
    • Certificate­Parsing­Exception ✔
    • Certificate­Revoked­Exception ✔
  • Cert­Path­Builder­Exception ✔
  • Cert­Path­Validator­Exception ✔
  • Cert­Store­Exception ✔
  • C­R­L­Exception ✔

Package java­.security­.spec

  • Invalid­Key­Spec­Exception ✔
  • Invalid­Parameter­Spec­Exception ✔

Package java­.sql

  • S­Q­L­Exception ✔

    • Batch­Update­Exception ✔
    • S­Q­L­Client­Info­Exception ✔
    • S­Q­L­Non­Transient­Exception ✔

      • S­Q­L­Data­Exception ✔
      • S­Q­L­Feature­Not­Supported­Exception ✔
      • S­Q­L­Integrity­Constraint­Violation­Exception ✔
      • S­Q­L­Invalid­Authorization­Spec­Exception ✔
      • S­Q­L­Non­Transient­Connection­Exception ✔
      • S­Q­L­Syntax­Error­Exception ✔
    • S­Q­L­Recoverable­Exception ✔
    • S­Q­L­Transient­Exception ✔

      • S­Q­L­Timeout­Exception ✔
      • S­Q­L­Transaction­Rollback­Exception ✔
      • S­Q­L­Transient­Connection­Exception ✔
    • S­Q­L­Warning ✔

      • Data­Truncation ✔

Package java­.text

  • Parse­Exception ✔

Package java­.time

  • Date­Time­Exception 1.8

Package java­.time­.format

  • Date­Time­Parse­Exception 1.8

Package java­.time­.temporal

  • Unsupported­Temporal­Type­Exception 1.8

Package java­.time­.zone

  • Zone­Rules­Exception 1.8

Package java­.util­.concurrent

  • Broken­Barrier­Exception ✔
  • Execution­Exception ✔
  • Completion­Exception 1.8
  • Cancellation­Exception
  • Rejected­Execution­Exception
  • Timeout­Exception ✔

Package java­.util­.jar

  • Jar­Exception ✔

Package java­.util­.prefs

  • Backing­Store­Exception ✔
  • Invalid­Preferences­Format­Exception ✔

Package java­.util­.regex

  • Pattern­Syntax­Exception

Package java­.util­.zip

  • Zip­Error
  • Data­Format­Exception ✔
  • Zip­Exception ✔

Package com­.sun­.jdi

  • Absent­Information­Exception ✔
  • Class­Not­Loaded­Exception ✔
  • Incompatible­Thread­State­Exception ✔
  • Invalid­Type­Exception ✔
  • Invocation­Exception ✔
  • Class­Not­Prepared­Exception
  • Inconsistent­Debug­Info­Exception
  • Internal­Exception
  • Invalid­Code­Index­Exception
  • Invalid­Line­Number­Exception
  • Invalid­Module­Exception 9
  • Invalid­Stack­Frame­Exception
  • Native­Method­Exception
  • Object­Collected­Exception
  • V­M­Cannot­Be­Modified­Exception
  • V­M­Disconnected­Exception
  • V­M­Mismatch­Exception
  • V­M­Out­Of­Memory­Exception

Package com­.sun­.jdi­.connect

  • Illegal­Connector­Arguments­Exception ✔
  • Transport­Timeout­Exception ✔
  • V­M­Start­Exception ✔

Package com­.sun­.jdi­.connect­.spi

  • Closed­Connection­Exception ✔

Package com­.sun­.jdi­.request

  • Duplicate­Request­Exception
  • Invalid­Request­State­Exception

Package com­.sun­.nio­.sctp

  • Invalid­Stream­Exception
  • Illegal­Receive­Exception
  • Illegal­Unbind­Exception

Package com­.sun­.tools­.attach

  • Agent­Initialization­Exception ✔
  • Agent­Load­Exception ✔
  • Attach­Not­Supported­Exception ✔
  • Attach­Operation­Failed­Exception ✔, 9

Package javax­.annotation­.processing

  • Filer­Exception ✔

Package javax­.crypto

  • Bad­Padding­Exception ✔

    • A­E­A­D­Bad­Tag­Exception ✔
  • Exemption­Mechanism­Exception ✔
  • Illegal­Block­Size­Exception ✔
  • No­Such­Padding­Exception ✔
  • Short­Buffer­Exception ✔

Package javax­.imageio

  • I­I­O­Exception ✔

Package javax­.imageio­.metadata

  • I­I­O­Invalid­Tree­Exception ✔

Package javax­.lang­.model

  • Unknown­Entity­Exception

Package javax­.lang­.model­.element

  • Unknown­Annotation­Value­Exception
  • Unknown­Directive­Exception 9
  • Unknown­Element­Exception

Package javax­.lang­.model­.type

  • Mirrored­Types­Exception

    • Mirrored­Type­Exception
  • Unknown­Type­Exception

Package javax­.management

  • Bad­Attribute­Value­Exp­Exception ✔
  • Bad­Binary­Op­Value­Exp­Exception ✔
  • Bad­String­Operation­Exception ✔
  • Invalid­Application­Exception ✔
  • J­M­Exception ✔

    • M­Bean­Exception ✔

      • M­Bean­Registration­Exception ✔
    • Operations­Exception ✔

      • Attribute­Not­Found­Exception ✔
      • Instance­Already­Exists­Exception ✔
      • Instance­Not­Found­Exception ✔
      • Introspection­Exception ✔
      • Invalid­Attribute­Value­Exception ✔
      • Listener­Not­Found­Exception ✔
      • Malformed­Object­Name­Exception ✔
      • Not­Compliant­M­Bean­Exception ✔
      • Service­Not­Found­Exception ✔
    • Reflection­Exception ✔
  • J­M­Runtime­Exception

    • Runtime­Error­Exception
    • Runtime­M­Bean­Exception
    • Runtime­Operations­Exception

Package javax­.management­.modelmbean

  • Invalid­Target­Object­Type­Exception ✔
  • X­M­L­Parse­Exception ✔

Package javax­.management­.monitor

  • Monitor­Setting­Exception

Package javax­.management­.openmbean

  • Open­Data­Exception ✔
  • Invalid­Key­Exception
  • Invalid­Open­Type­Exception
  • Key­Already­Exists­Exception

Package javax­.management­.relation

  • Relation­Exception ✔

    • Invalid­Relation­Id­Exception ✔
    • Invalid­Relation­Service­Exception ✔
    • Invalid­Relation­Type­Exception ✔
    • Invalid­Role­Info­Exception ✔
    • Invalid­Role­Value­Exception ✔
    • Relation­Not­Found­Exception ✔
    • Relation­Service­Not­Registered­Exception ✔
    • Relation­Type­Not­Found­Exception ✔
    • Role­Info­Not­Found­Exception ✔
    • Role­Not­Found­Exception ✔

Package javax­.management­.remote

  • J­M­X­Provider­Exception ✔
  • J­M­X­Server­Error­Exception ✔

Package javax­.naming

  • Naming­Exception ✔

    • Cannot­Proceed­Exception ✔
    • Communication­Exception ✔
    • Configuration­Exception ✔
    • Context­Not­Empty­Exception ✔
    • Insufficient­Resources­Exception ✔
    • Interrupted­Naming­Exception ✔
    • Invalid­Name­Exception ✔
    • Limit­Exceeded­Exception ✔

      • Size­Limit­Exceeded­Exception ✔
      • Time­Limit­Exceeded­Exception ✔
    • Link­Exception ✔

      • Link­Loop­Exception ✔
      • Malformed­Link­Exception ✔
    • Name­Already­Bound­Exception ✔
    • Name­Not­Found­Exception ✔
    • Naming­Security­Exception ✔

      • Authentication­Exception ✔
      • Authentication­Not­Supported­Exception ✔
      • No­Permission­Exception ✔
    • No­Initial­Context­Exception ✔
    • Not­Context­Exception ✔
    • Operation­Not­Supported­Exception ✔
    • Partial­Result­Exception ✔
    • Referral­Exception ✔
    • Service­Unavailable­Exception ✔

Package javax­.naming­.directory

  • Attribute­In­Use­Exception ✔
  • Attribute­Modification­Exception ✔
  • Invalid­Attribute­Identifier­Exception ✔
  • Invalid­Attributes­Exception ✔
  • Invalid­Attribute­Value­Exception ✔
  • Invalid­Search­Controls­Exception ✔
  • Invalid­Search­Filter­Exception ✔
  • No­Such­Attribute­Exception ✔
  • Schema­Violation­Exception ✔

Package javax­.naming­.ldap

  • Ldap­Referral­Exception ✔

Package javax­.net­.ssl

  • S­S­L­Exception ✔

    • S­S­L­Handshake­Exception ✔
    • S­S­L­Key­Exception ✔
    • S­S­L­Peer­Unverified­Exception ✔
    • S­S­L­Protocol­Exception ✔

Package javax­.print

  • Print­Exception ✔

Package javax­.print­.attribute

  • Unmodifiable­Set­Exception

Package javax­.script

  • Script­Exception ✔

Package javax­.security­.auth

  • Destroy­Failed­Exception ✔
  • Refresh­Failed­Exception ✔

Package javax­.security­.auth­.callback

  • Unsupported­Callback­Exception ✔

Package javax­.security­.auth­.login

  • Login­Exception ✔

    • Account­Exception ✔

      • Account­Expired­Exception ✔
      • Account­Locked­Exception ✔
      • Account­Not­Found­Exception ✔
    • Credential­Exception ✔

      • Credential­Expired­Exception ✔
      • Credential­Not­Found­Exception ✔
    • Failed­Login­Exception ✔

Package javax­.security­.cert

  • Certificate­Exception ✔

    • Certificate­Encoding­Exception ✔
    • Certificate­Expired­Exception ✔
    • Certificate­Not­Yet­Valid­Exception ✔
    • Certificate­Parsing­Exception ✔

Package javax­.security­.sasl

  • Sasl­Exception ✔

    • Authentication­Exception ✔

Package javax­.smartcardio

  • Card­Exception ✔

    • Card­Not­Present­Exception ✔

Package javax­.sound­.midi

  • Invalid­Midi­Data­Exception ✔
  • Midi­Unavailable­Exception ✔

Package javax­.sound­.sampled

  • Line­Unavailable­Exception ✔
  • Unsupported­Audio­File­Exception ✔

Package javax­.sql­.rowset

  • Row­Set­Warning ✔

Package javax­.sql­.rowset­.serial

  • Serial­Exception ✔

Package javax­.sql­.rowset­.spi

  • Sync­Factory­Exception ✔
  • Sync­Provider­Exception ✔

Package javax­.swing

  • Unsupported­Look­And­Feel­Exception ✔

Package javax­.swing­.text

  • Bad­Location­Exception ✔
  • Changed­Char­Set­Exception ✔

Package javax­.swing­.tree

  • Expand­Veto­Exception ✔

Package javax­.swing­.undo

  • Cannot­Redo­Exception
  • Cannot­Undo­Exception

Package javax­.transaction­.xa

  • X­A­Exception ✔

Package javax­.xml­.catalog

  • Catalog­Exception 9

Package javax­.xml­.crypto

  • Key­Selector­Exception ✔
  • Marshal­Exception ✔
  • No­Such­Mechanism­Exception
  • U­R­I­Reference­Exception ✔

Package javax­.xml­.crypto­.dsig

  • Transform­Exception ✔
  • X­M­L­Signature­Exception ✔

Package javax­.xml­.datatype

  • Datatype­Configuration­Exception ✔

Package javax­.xml­.parsers

  • Factory­Configuration­Error
  • Parser­Configuration­Exception ✔

Package javax­.xml­.stream

  • Factory­Configuration­Error
  • X­M­L­Stream­Exception ✔

Package javax­.xml­.transform

  • Transformer­Factory­Configuration­Error
  • Transformer­Exception ✔

    • Transformer­Configuration­Exception ✔

Package javax­.xml­.validation

  • Schema­Factory­Configuration­Error 1.8

Package javax­.xml­.xpath

  • X­Path­Exception ✔

    • X­Path­Expression­Exception ✔

      • X­Path­Function­Exception ✔
    • X­Path­Factory­Configuration­Exception ✔

Package jdk­.dynalink

  • No­Such­Dynamic­Method­Exception

Package jdk­.jshell

  • J­Shell­Exception ✔, 9

    • Eval­Exception ✔, 9
    • Unresolved­Reference­Exception ✔, 9

Package jdk­.jshell­.spi

  • Execution­Control­Execution­Control­Exception ✔

    • Execution­Control­Class­Install­Exception ✔
    • Execution­Control­Engine­Termination­Exception ✔
    • Execution­Control­Internal­Exception ✔

      • Execution­Control­Not­Implemented­Exception ✔
    • Execution­Control­Run­Exception ✔

      • Execution­Control­Resolution­Exception ✔
      • Execution­Control­Stopped­Exception ✔
      • Execution­Control­User­Exception ✔
  • S­P­I­Resolution­Exception 9

Package jdk­.nashorn­.api­.scripting

  • Nashorn­Exception 1.8u40

Package jdk­.nashorn­.api­.tree

  • Unknown­Tree­Exception 9

Package jdk­.security­.jarsigner

  • Jar­Signer­Exception 9

Package netscape­.javascript

  • J­S­Exception

Package org­.ietf­.jgss

  • G­S­S­Exception ✔

Package org­.w3c­.dom

  • D­O­M­Exception

Package org­.w3c­.dom­.events

  • Event­Exception

Package org­.w3c­.dom­.ls

  • L­S­Exception

Package org­.w3c­.dom­.ranges

  • Range­Exception 9, DOM Level 2

Package org­.w3c­.dom­.xpath

  • X­Path­Exception

Package org­.xml­.sax

  • S­A­X­Exception ✔

    • S­A­X­Not­Recognized­Exception ✔
    • S­A­X­Not­Supported­Exception ✔
    • S­A­X­Parse­Exception ✔

Comments

Be the first to comment!

Источник

% Throwable

Класс: java.lang.Throwable

Описание

Throwable — базовый класс всех исключений Java. В инструкциях throw и catch можно использовать только
объекты класса Throwable и его подклассов.

Объект-исключение содержит в себе текстовое сообщение, говорящее о причине ошибки, трассировку стека вызовов на момент
создания, а также, возможно, причину (cause) — исключение более низкого уровня, завёрнутое в данное исключение.

Иерархия исключений

Все исключения в Java делятся на две большие и неравные группы. Меньшая группа наследует от класса Error и обозначает
серьёзные низкоуровневые ошибки, после которых продолжение выполнения программы обычно бессмысленно. Большая группа
наследует от класса Exception и отвечает за обычные нештатные ситуации, которые могут возникнуть в ходе выполнения
программы.

Теоретически язык Java не запрещает определить свой подкласс класса Throwable, не производный ни от Error, ни от
Exception. Компилятор будет рассматривать такую неведому зверушку как обычное проверяемое исключение (см. ниже), но
на практике так никто не поступает, да и необходимости в этом нет.

Проверяемые и непроверяемые исключения

Классы Error и RuntimeException занимают особое положение в иерархии исключений. Эти классы, а также все производные
от них, являются непроверяемыми исключениями (unchecked exceptions). Все остальные исключения являются проверяемыми
(checked exceptions). На диаграмме классов выше непроверяемые исключения выделены голубым, а проверяемые
— зелёным.

Метод, внутри которого может быть выброшено проверяемое исключение, должен либо обработать его в блоке catch, либо
передать выше и явно сказать об этом в объявлении с помощью ключевого слова throws (и тогда разбираться с ним будут
уже где-то выше). На непроверяемые исключения компилятор не налагает таких требований.

void throwsIOException() throws IOException {
	if (MoonPhase.getCurrent() == MoonPhase.FULL) {
		// непроверяемое исключение; можно обработать, но компилятор не заставляет
		throw new IllegalStateException();
	} else {
		// проверяемое исключение
		throw new IOException();
	}
}

void handlesIOException() {
	try {
		throwsIOException();
	} catch (IOException e) {
		e.printStackTrace();
	}
}

В стандартной библиотеке есть одно нарушение этого правила. Статический метод Class.newInstance передаёт во внешний
код любые исключения, в том числе проверяемые, что позволяет обойти проверки времени компиляции:

public class Thrower {
    private Thrower () throws IOException {
        throw new IOException();
    }

    public static void main(String[] args) {
        try {
            Thrower t = Thrower.class.newInstance();
        } catch (IllegalAccessException | InstantiationException e) {
            // Ну хотя бы эти нужно обрабатывать, но уже поздно
        }
    }
}

Здесь main упадёт по IOException, хотя обычно компилятор заставил бы нас объявить его как throws IOException.
Мораль в том, что при использовании рефлексии всегда нужно быть осторожными, потому что она предоставляет внеязыковой
механизм манипуляции классами и методами.

Ошибки (Error)

Исключения, производные от класса Error, являются непроверяемыми и обладают объединяющими свойствами:

  1. Они сигнализируют о серьёзных ошибках низкого уровня, после которых восстановление обычно невозможно.
  2. Многие из них (в частности, OutOfMemoryError, LinkageError и ThreadDeath) могут возникнуть практически в любом
    месте программы, поэтому настраиваться на них заранее обычно бессмысленно. Кроме того, место, где выбрасывается
    исключение, обычно не связано с местом логического возникновения нижележащей проблемы.

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

Вот некоторые наиболее распространённые исключения типа Error:

StackOverflowError
: Переполнение стека вызовов. Обычно это указывает на бесконечную рекурсию.

OutOfMemoryError
: Переполнение кучи, причём сборщик мусора уже попытался её почистить и беспомощно развёл руками. Обычно это указывает
на утечки памяти, вызванные хранением ссылок на множество ненужных объектов в корневых переменных.

LinkageError
: Базовый класс для различных ошибок при загрузке классов, необходимых для работы выполняемого кода. Сюда относятся в
том числе NoClassDefFoundError и ExceptionInInitializerError.

NoClassDefFoundError
: JVM не может найти класс, к которому пытается обратиться код. Это может случиться, если код был скомпилирован с
зависимостью от какого-то класса или библиотеки, но запущен при отсутствии этого класса/библиотеки в classpath.

ExceptionInInitializerError
: При инициализации статического поля класса или внутри блока static выбросилось исключение, к которому можно
доступиться через метод getCause.

ThreadDeath
: В многопоточной программе чужой поток нагло и бесцеремонно завершил работу нашего потока методом Thread.stop. Если
поток завершается по этому исключению, по умолчанию сообщение об ошибке подавляется и не пишется в консоль.

AssertionError
: Нарушено базовое условие, которое в корректно работающей программе должно выполняться всегда. Исключения этого класса
бросает инструкция assert при запуске JVM с параметром -ea (enable assertions), а также библиотека JUnit при провале
тестов.

Как правило, не стоит выбрасывать исключения типа Error инструкцией throw, кроме исключения AssertionError. Его
принято выбрасывать как «невозможное» исключение, чтобы «заткнуть» выбросом исключения пути выполнения, которые заведомо
никогда не будут выполнены, но компилятор об этом не знает. Часто это приходится делать при использовании перечислимых
типов в инструкции switch:

public enum Stoplight { RED, YELLOW, GREEN }
public enum CarState { STOPPED, STOPPING, MOVING }

public class Car {
	public CarState approachIntersection(Intersection intersection) {
		switch (intersection.getStoplight()) {
		case RED:
			stop();
			return CarState.STOPPING;
		case YELLOW:
			if (stopIfPossible()) {
				return CarState.STOPPING;
			} else {
				return CarState.MOVING;
			}
		case GREEN:
			keepMoving();
			return CarState.MOVING;
		default:
			// не может случиться
			throw new AssertionError();
		}
	}
	
	public CarState handleStoplightSwitch(Stoplight stoplight) {
		switch (stoplight) {
		case RED:
			return CarState.STOPPED;
		case YELLOW:
			prepareToMove();
			return CarState.STOPPED;
		case GREEN:
			startMoving();
			return CarState.MOVING;
		default:
			// не может случиться
			throw new AssertionError();
		}
	}
}

В нашем случае у светофора всего три возможных состояния, но компилятор тем не менее требует, чтобы блок switch
обработал невозможную ситуацию default. С помощью throw new AssertionError мы затыкаем компилятор и говорим
сопровождающему код, что эта строка кода заведомо не выполнится.

Ещё один частый use case для AssertionError — блок catch для исключения, невозможного по определению.
Например, стандартные классы URLEncoder и URLDecoder имеют методы, принимающие два параметра: перекодируемую строку
и строку с именем кодировки.

String url = "https://ru.wikipedia.org/wiki/%D0%A1%D1%82%D0%B5%D0%BA";
String decodedUrl = URLDecoder.decode(url, "UTF-8");

Этот код просто так не скомпилируется, потому что метод URLDecoder.decode объявлен как
throws UnsupportedEncodingException. Однако кодировка UTF-8 гарантированно поддерживается в любой реализации JVM,
поэтому на самом деле это исключение никогда не выбросится (но компилятор, увы, об этом не знает). Нам придётся
обернуть этот код в идиому «невозможное исключение» (impossible exception):

try {
	String url = "https://ru.wikipedia.org/wiki/%D0%A1%D1%82%D0%B5%D0%BA";
	String decodedUrl = URLDecoder.decode(url, "UTF-8");
	// https://ru.wikipedia.org/wiki/Стек
} catch (UnsupportedEncodingException e) {
	// не может случиться
	throw new AssertionError(e);
}

Большинство методов, работающих с кодировками, имеют версии, принимающие вместо строки с именем кодировки объект
класса Charset и не бросающие UnsupportedEncodingException. Им можно передавать константы из класса
StandardCharsets:

List<String> fileContents = Files.readAllLines(
		Paths.get("отчёт.txt"), StandardCharsets.UTF_8);
fileContents.forEach(System.out::println);

К сожалению, некоторые старые классы, в том числе URLEncoder и URLDecoder, так и не были обновлены для поддержки
параметров типа Charset.

Исключения времени выполнения (RuntimeException)

Строго говоря, все исключения возникают во время выполнения, но класс RuntimeException занимает особое положение.
Во-первых, RuntimeException и все производные от него исключения являются непроверяемыми. Во-вторых,
многие из этих исключений сигнализируют об ошибках в программном коде и в корректно написанной программе не должны
возникать вообще. Такие исключения полезно выбрасывать в собственных public-методах в качестве предусловий
(preconditions), краткий смысл которых состоит в том, чтобы сказать вызывающему коду: «Ты виноват, такой ситуации вообще
не должно быть».

Вот некоторые самые важные из них:

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

IllegalArgumentException
: Метод был вызван с недопустимым значением параметра. Например, один из конструкторов стандартного класса Color,
принимающий три целых числа RGB, выбрасывает это исключение, если переданные числа не лежат в диапазоне 0–255.

IllegalStateException
: Объект находится в состоянии, в котором выполнение операции невозможно. Например, реализация стека может выбросить
это исключение при попытке извлечь элемент из пустого стека.

IndexOutOfBoundsException
: Попытка обратиться к упорядоченной последовательности элементов (массиву, строке или списку) по индексу, лежащему
вне допустимых значений. Часто происходит при ошибке на единицу, когда в качестве индекса используется length или
size.

NoSuchElementException
: Выбрасывается итератором при попытке прочитать элемент за концом последовательности (когда hasNext() == false). В
корректной реализации итератора это исключение возможно только при ручной работе с итератором и невозможно при
использовании цикла for-each.

UnsupportedOperationException
: Вызываемая операция в принципе запрещена для этого объекта. Например, неизменяемые коллекции выбрасывают это
исключение при попытке изменить их методами set, add или remove.

ArithmeticException
: Вызвана недопустимая арифметическая операция, например, деление на ноль. Операции над числами с плавающей точкой не
выбрасывают это исключение, вместо этого при недопустимой операции они возвращают значение NaN (а при делении
ненулевого числа на ноль — бесконечность).

ClassCastException
: Попытка привести объект к несовместимому типу, например, (String) new Object().

Все эти исключения объединяет то, что в корректно написанной программе они не должны выбрасываться. Если одно из этих
исключений ловится в программе, это знак неверной логики кода. Часто отлов такого исключения можно заменить проверкой;
например, вместо отлова ClassCastException использовать оператор instanceof, вместо IndexOutOfBoundsException
— проверку диапазона (index >= 0 && index < size()), а вместо NoSuchElementException — проверку
Iterator.hasNext().

Прочие исключения (Exception)

Исключения, производные от Exception, но не RuntimeException, являются проверяемыми. Их очень много, и сторонние
библиотеки часто добавляют свои собственные классы исключений. Вот лишь несколько примеров:

ReflectiveOperationException
: Базовый класс для исключений, возникающих при работе с механизмом рефлексии. Сюда относятся IllegalAccessException
(попытка доступиться извне к членам класса с доступом private, protected или package-private), NoSuchMethodException
(метод не найден) и InvocationTargetException (оборачивает исключение, выброшенное вызываемым через рефлексию
методом). Отдельно стоит выделить…

ClassNotFoundException
: Не путать с NoClassDefFoundError. Выбрасывается методом Class.forName, если класс с таким именем не найден. Это
исключение, в отличие от NoClassDefFoundError, предназначено для того, чтобы его перехватывали и обрабатывали.

CloneNotSupportedException
: По умолчанию выбрасывается protected-методом Object.clone, если объект не реализует интерфейс Cloneable. По
каким-то непонятным причинам конченые укурки, проектировавшие Java 1.0, сделали это исключение проверяемым, и при
реализации Cloneable-классов это исключение приходится подавлять.

SQLException
: Базовый класс для ошибок при работе с базами данных через JDBC API.

IOException
: Базовый класс для исключений при операциях ввода-вывода, к которым относятся операции, в том числе, с файловой
системой и сетью. У этого класса очень много подклассов, обозначающих конкретные ситуации; например,
ConnectException бросается при неудачной попытке соединения с сервером.

FileSystemException
: Подкласс IOException, являющийся базовым классом для исключений при операциях с файловой системой.

AccessDeniedException
: Попытка обратиться к файлу, на доступ к которому у пользователя нет прав — например, попытка открыть
защищённый системный файл для записи.

NoSuchFileException
: Попытка обратиться к несуществующему файлу.

Класс NoSuchFileException появился в Java 7 и является частью нового файлового API (классы Path и Files). В
старых API, спроектированных для Java 6 и ниже, можно встретить более старое исключение FileNotFoundException,
присутствовавшее ещё в Java 1.0. К сожалению, это исключение не позволяет различить ситуации «файл не найден» и «доступ
запрещён» и выбрасывается старыми API в обоих этих случаях.

Использование проверяемых и непроверяемых исключений

Тема проверяемых и непроверяемых исключений, а также правил их использования, сломала немало копий (и кода). Полного
консенсуса по этому вопросу нет, но можно пользоваться эмпирическим правилом.

Выбрасывайте проверяемые исключения только при одновременном выполнении трёх условий:

  1. Вызывающий код не может гарантированно избежать ошибочной ситуации, то есть она находится вне его полного контроля.
  2. Ошибочная ситуация является «стандартной», то есть в любом случае автору вызывающего кода нужно думать о том, что
    произойдёт при возникновении ошибки. Например, при попытке открыть файл может оказаться, что файл недоступен.
  3. Вызывающий код может осмысленно обработать ошибку или даже восстановиться после неё.

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

Если хотя бы одно из этих трёх условий не выполняется, используйте непроверяемые исключения. Вот примеры ошибок, для
которых подходят непроверяемые исключения:

  • Низкоуровневые ошибки самой JVM и загруженных классов (Error).
  • Ошибки в логике программы, необнаружимые на этапе компиляции (RuntimeException).
  • Ошибки, при которых продолжение выполнения кода не имеет смысла. Например, в серверных приложениях это могут быть
    ошибки конфигурации сервера, при которых приложение вообще не может запуститься, или ошибки доступа к основной базе
    данных, с которой работает серверное приложение (здесь само приложение всё равно не сможет восстановиться). Как правило,
    такие исключения тоже наследуют от RuntimeException.

Создание исключения

Объекты исключений, как правило, создаются прямо в инструкции throw:

throw new SomeException(параметры);

По соглашению у большинства классов исключений есть четыре конструктора, позволяющие задать исключению сообщение и/или
причину — более низкоуровневое исключение.

SomeException()

SomeException(String message)

SomeException(Throwable cause)

SomeException(String message, Throwable cause)

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

try {
	readConfigFile("server-config.xml");
} catch (XMLStreamException e) {
	throw new ServerStartupException("Invalid server configuration format", e);
} catch (IOException e) {
	throw new ServerStartupException("Cannot access server configuration", e);
}

У некоторых очень старых классов исключений, написанных до выхода Java 1.4, может не быть конструкторов с параметром
cause. Для них можно установить причину после создания объекта с помощью метода initCause:

throw new OldException("Message").initCause(e);

Получение информации об исключении

Все исключения поддерживают три базовых операции:

String getMessage()
: Возвращает короткое, в одно-два предложения, сообщение об ошибке, переданное в объект исключения при его создании.

Throwable getCause()
: Возвращает исключение, послужившее причиной данного исключения, или null, если таковое не было задано. У причины,
в свою очередь, тоже может быть причина; с помощью последовательных вызовов getCause можно восстановить причинную
цепь исключений (causal chain).

void printStackTrace()
void printStackTrace(PrintStream s)
void printStackTrace(PrintWriter s)
: Выводит трассировку стека (stack trace) в указанный байтовый или символьный поток (по умолчанию — в
System.err). Варианты с PrintStream и PrintWriter бывают полезны, чтобы записать трассировку стека в файл или
сетевой поток, либо получить её в виде строки с помощью StringWriter.

Если у исключения есть причина, методы printStackTrace вслед за трассировкой стека самого исключения печатают
трассировку стека его причины, затем — причины причины и так далее.

По умолчанию для всех исключений, кроме ThreadDeath, при завершении потока по необработанному исключению трассировка
стека записывается в System.err с помощью printStackTrace. Это относится и к главному потоку при аварийном
завершении метода main.

Как пример, вот такая неправильная программа

public class ExceptionChain {
	private static class BadInitializer {
		private static final char CONSTANT = "Hello".charAt(5);
	}
	
	public static void main(String[] args) {
		System.out.println(BadInitializer.CONSTANT);
	}
}

при выполнении выдаст:

Exception in thread "main" java.lang.ExceptionInInitializerError
	at ExceptionChain.main(ExceptionChain.java:11)
Caused by: java.lang.StringIndexOutOfBoundsException: String index out of range: 5
	at java.lang.String.charAt(String.java:658)
	at ExceptionChain$BadInitializer.<clinit>(ExceptionChain.java:7)
	... 1 more
Источник

Исключение в Java представляет проблему, которая возникает в ходе выполнения программы. В случае возникновения в Java исключения (exception), или исключительного события, имеет место прекращение нормального течения программы, и программа/приложение завершаются в аварийном режиме, что не является рекомендованным, и, как следствие, подобные случаи требуют в Java обработку исключений.

Причины возникновения исключения

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

  • Пользователь ввел недопустимые данные.
  • Файл, который необходимо открыть, не найден.
  • Соединение с сетью потеряно в процессе передачи данных либо JVM исчерпала имеющийся объем памяти.

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

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

  • Контролируемые исключения – контролируемое исключение представляет собой вид исключения, которое происходит на стадии компиляции, их также именуют исключениями периода компиляции. Обозначенные исключения не следует игнорировать в ходе компиляции, они требуют должного обращения (разрешения) со стороны программиста.

К примеру, если вы используете класс FileReader в вашей программе для считывания данных из файла, в случае, если указанный в конструкторе файл не существует, происходит FileNotFoundException, и компилятор подсказывает программисту обработку данного исключения.

Пример 1

import java.io.File;
import java.io.FileReader;

public class Test {

   public static void main(String args[]) {		
      File f = new File("D://java/file.txt");
      FileReader fr = new FileReader(f); 
   }
}

При попытке компиляции обозначенной выше программы будут выведены следующие исключения:

C:>javac Test.java
Test.java:8: error: unreported exception FileNotFoundException; must be caught or declared to be thrown
      FileReader fr = new FileReader(f);
                      ^
1 error

Примечание. В виду того, что методы read() и close() класса FileReader вызывают IOException, компилятор может уведомить вас об обработке IOException, совместно с FileNotFoundException.

  • Неконтролируемые исключения – неконтролируемое исключение представляет собой исключение, которое происходит во время выполнения. Они также носят название исключения на этапе выполнения. Данная категория может включать погрешности программирования, такие как логические ошибки либо неверный способ использования API. Исключения на этапе выполнения игнорируются в ходе компиляции.

К примеру, если вами в вашей программе был объявлен массив из 5 элементов, попытка вызова 6-го элемента массива повлечет за собой возникновение ArrayIndexOutOfBoundsExceptionexception.

Пример 2

public class Test {
   
   public static void main(String args[]) {
      int array[] = {1, 2, 3};
      System.out.println(array[4]);
   }
}

При компиляции и выполнении обозначенной выше программы будет получено следующее исключение:

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 5
	at Exceptions.Test.main(Test.java:8)
  • Ошибки – не являются исключениями, однако представляют проблемы, которые возникают независимо от пользователя либо программиста. Ошибки в вашем коде обычно игнорируются в виду того, что в редких случаях их обработка окажется результативной. К примеру, ошибка возникнет при переполнении стека. На этапе компиляции они также игнорируются.

Иерархия исключений

Все классы исключений в Java представляют подтипы класса java.lang.Exception. Класс исключений является подклассом класса Throwable. Помимо класса исключений существует также подкласс ошибок, образовавшихся из класса Throwable.

Ошибки представляют аварийное состояние вследствие значительных сбоев, которые не обрабатываются программами Java. Генерирование ошибок предназначено для отображения ошибок, выявленных средой выполнения. Примеры: JVM исчерпал имеющийся объем памяти. Обычно, программы не могут восстановить неполадки, вызванные ошибками.

Класс исключений делится на два основных подкласса: класс IOException и класс RuntimeException.

Иерархия исключений, исключения в Java, Java, RuntimeException Class

По ссылке представлен перечень наиболее распространенных контролируемых (checked) и неконтролируемых (unchecked) встроенных исключений в Java.

Методы исключений

Далее представлен список важных методов, доступных в классе Throwable.

№ Метод и описание
1 public String getMessage()
Возврат подробного сообщения о произошедшем исключении. Инициализация данного сообщения производится в конструкторе Throwable.
2 public Throwable getCause()
Возврат причины исключения, представленной объектом Throwable.
3 public String toString()
Возврат имени класса, соединенного с результатом getMessage().
4 public void printStackTrace()
Выведение результата toString() совместно с трассировкой стека в System.err, поток вывода ошибок.
5 public StackTraceElement [] getStackTrace()
Возврат массива, содержащего каждый элемент в трассировке стека. Элемент с номером 0 представляет вершину стека вызовов, последний элемент массива отображает метод на дне стека вызовов.
6 public Throwable fillInStackTrace()
Заполняет трассировку стека данного объекта Throwable текущей трассировкой стека, дополняя какую-либо предшествующую информацию в трассировке стека.

Обработка исключений – try и catch

Метод производит обработку исключения при использовании ключевых слов try и catch.

Описание

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

try {
   // Защищенный код
}catch(НазваниеИсключения e1) {
   // Блок catch
}

Код, предрасположенный к исключениям, размещается в блоке try. В случае возникновения исключения, обработка данного исключения будет производиться соответствующим блоком catch. За каждым блоком try должен немедленно следовать блок catch либо блок finally.

Оператор catch включает объявление типа исключения, которое предстоит обработать. При возникновении исключения в защищенном коде, блок catch (либо блоки), следующий за try, будет проверен. В случае, если тип произошедшего исключения представлен в блоке catch, исключение передается в блок catch аналогично тому, как аргумент передается в параметр метода.

Пример

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

import java.io.*;

public class Test {

   public static void main(String args[]) {
      try {
         int array[] = new int[2];
         System.out.println("Доступ к третьему элементу:" + array[3]);
      }catch(ArrayIndexOutOfBoundsException e) {
         System.out.println("Исключение:" + e);
      }
      System.out.println("Вне блока");
   }
}

Вследствие этого будет получен следующий результат:

Исключение:java.lang.ArrayIndexOutOfBoundsException: 3
Вне блока

Многократные блоки catch

За блоком try могут следовать несколько блоков catch. Синтаксис многократных блоков catch выглядит следующим образом:

try {
   // Защищенный код
}catch(ИсключениеТип1 e1) {
   // Блок catch
}catch(ИсключениеТип2 e2) {
   // Блок catch
}catch(ИсключениеТип3 e3) {
   // Блок catch
}

Представленные выше операторы демонстрируют три блока catch, однако, после однократного try количество данных используемых блоков может быть произвольным. В случае возникновения исключения в защищенном коде, исключение выводится в первый блок catch в списке. Если тип данных генерируемого исключения совпадает с ИсключениеТип1, он перехватывается в указанной области. В обратном случае, исключение переходит ко второму оператору catch. Это продолжается до тех пор, пока не будет произведен перехват исключения, либо оно не пройдет через все операторы, в случае чего выполнение текущего метода будет прекращено, и исключение будет перенесено к предшествующему методу в стеке вызовов.

Пример

Далее представлен сегмент кода, демонстрирующий использование многократных операторов try/catch.

try {
   file = new FileInputStream(fileName);
   x = (byte) file.read();
}catch(IOException e1) {
   e1.printStackTrace();
   return -1;
}catch(FileNotFoundException e2) // Недействительно! {
   e2.printStackTrace();
   return -1;
}

Перехват многотипных исключений

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

catch (IOException|FileNotFoundException ex) {
   logger.log(ex);
   throw ex;

Ключевые слова throws/throw

В случае если метод не может осуществить обработку контролируемого исключения, производится соответствующее уведомление при использовании ключевого слова throws в Java. Ключевое слово throws появляется в конце сигнатуры метода.

При использовании ключевого слова throw вы можете произвести обработку вновь выявленного исключения либо исключения, которое было только что перехвачено.

Следует внимательно различать ключевые слова throw и throws в Java, так как throws используется для отложенной обработки контролируемого исключения, а throw, в свою очередь, используется для вызова заданного исключения.

Представленный ниже метод отображает, что им генерируется RemoteException:

Пример 1

import java.rmi.RemoteException;
public class Test {

   public void deposit(double amount) throws RemoteException {
      // Реализация метода
      throw new RemoteException();
   }
   // Остаток определения класса
}

Метод также может объявить о том, что им генерируется более чем одно исключение, в случае чего исключения представляются в виде перечня, отделенные друг от друга запятыми. К примеру, следующий метод оповещает о том, что им генерируются RemoteException и InsufficientFundsException:

Пример 2

import java.rmi.RemoteException;
public class Test {

   public void withdraw(double amount) throws RemoteException, 
      InsufficientFundsException {
      // Реализация метода
   }
   // Остаток определения класса
}

Блок finally

В Java finally следует за блоком try либо блоком catch. Блок finally в коде выполняется всегда независимо от наличия исключения.

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

Блок finally в Java появляется по окончании блоков catch, его синтаксис выглядит следующим образом:

Синтаксис

try {
   // Защищенный код
}catch(ИсключениеТип1 e1) {
   // Блок catch
}catch(ИсключениеТип2 e2) {
   // Блок catch
}catch(ИсключениеТип3 e3) {
   // Блок catch
}finally {
   // Блок finally всегда выполняется.
}

Пример

public class Test {

   public static void main(String args[]) {
      int array[] = new int[2];
      try {
         System.out.println("Доступ к третьему элементу:" + array[3]);
      }catch(ArrayIndexOutOfBoundsException e) {
         System.out.println("Исключение:" + e);
      }finally {
         array[0] = 6;
         System.out.println("Значение первого элемента: " + array[0]);
         System.out.println("Оператор finally выполнен.");
      }
   }
}

Вследствие этого будет получен следующий результат:

Исключение:java.lang.ArrayIndexOutOfBoundsException: 3
Значение первого элемента: 6
Оператор finally выполнен.

Следует помнить, что:

  • Выражение catch не может существовать без оператора try.
  • При наличии блока try/catch, выражение finally не является обязательным.
  • Блок try не может существовать при отсутствии выражения catch либо выражения finally.
  • Существование какого-либо кода в промежутке между блоками try, catch, finally является невозможным.

Конструкция try-with-resources

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

Пример 1

import java.io.FileReader;
import java.io.File;
import java.io.IOException;

public class Test {

   public static void main(String args[]) {
      FileReader fr = null;		
      try {
         File f = new File("file.txt");
         fr = new FileReader(f); 
         char [] array = new char[10];
         fr.read(array);   // чтение содержимого массива
         for(char c : array)
         System.out.print(c);   // вывод символов на экран, один за одним
      }catch(IOException e1) {
         e1.printStackTrace();
      }finally {
         try {
            fr.close();
         }catch(IOException e2) {		
            e2.printStackTrace();
         }
      }
   }
}

Конструкция try-with-resources, также именуемая как автоматическое управление ресурсами, представляет новый механизм обработки исключений, который был представлен в 7-ой версии Java, осуществляя автоматическое закрытие всех ресурсов, используемых в рамках блока try catch.

Чтобы воспользоваться данным оператором, вам всего лишь нужно разместить заданные ресурсы в круглых скобках, после чего созданный ресурс будет автоматически закрыт по окончании блока. Ниже представлен синтаксис конструкции try-with-resources.

Синтаксис

try(FileReader fr = new FileReader("Путь к файлу")) {
   // использование ресурса
   }catch() {
      // тело catch 
   }
}

Программа ниже производит считывание данных в файле, используя конструкцию try-with-resources.

Пример 2

import java.io.FileReader;
import java.io.IOException;

public class Test {

   public static void main(String args[]) {
      try(FileReader fr = new FileReader("E://Soft/NetBeans 8.2/Projects/test/test/file.txt")) {
         char [] array = new char[10];
         fr.read(array);   // чтение содержимого массива
         for(char c : array)
         System.out.print(c);   // вывод символов на экран, один за одним
      }catch(IOException e) {
         e.printStackTrace();
      }
   }
}

При работе с конструкцией try-with-resources следует принимать во внимание следующие нюансы:

  • С целью использования конструкции try-with-resources следует реализовать интерфейс AutoCloseable, после чего соответствующий метод close() будет вызван автоматически во время выполнения.
  • В конструкции try-with-resources возможно указание одного и более классов.
  • При указании нескольких классов в блоке try конструкции try-with-resources, закрытие данных классов будет производиться в обратном порядке.
  • За исключением внесения ресурсов в скобки, все элементы являются равными аналогично нормальному блоку try/catch в составе блока try.
  • Ресурсы, внесенные в try, конкретизируются до запуска блока try.
  • Ресурсы непосредственно в составе блока try указываются как окончательные.

Создание своих собственных исключений

Вы можете создать свои собственные исключения в среде Java. При записи собственных классов исключений следует принимать во внимание следующие аспекты:

  • Все исключения должны быть дочерними элементами Throwable.
  • Если вы планируете произвести запись контролируемого исключения с автоматическим использованием за счет правила обработки или объявления, вам следует расширить класс Exception.
  • Если вы хотите произвести запись исключения на этапе выполнения, вам следует расширить класс RuntimeException.

Вы можете определить собственный класс исключений, как показано ниже:

class MyException extends Exception {
}

Вам лишь необходимо расширить предопределенный класс Exception с целью создания собственного исключения. Данная категория относится к контролируемым исключениям. Следующий класс InsufficientFundsException исключительных ситуаций, определяемых пользователем, расширяет класс Exception, делая его контролируемым исключением. Класс исключений, подобно всем остальным классам, содержит используемые области и методы.

Пример

// Название файла InsufficientFundsException.java
import java.io.*;

public class InsufficientFundsException extends Exception {
   private double amount;
   
   public InsufficientFundsException(double amount) {
      this.amount = amount;
   }
   
   public double getAmount() {
      return amount;
   }
}

С целью демонстрации наших исключений, определяемых пользователем, следующий класс Checking содержит метод withdraw(), генерирующий InsufficientFundsException.

// Название файла Checking.java
import java.io.*;

public class Checking {
   private int number;
   private double balance;
   
   public Checking(int number) {
      this.number = number;
   }
   
   public void deposit(double amount) {
      balance += amount;
   }
   
   public void withdraw(double amount) throws InsufficientFundsException {
      if(amount <= balance) {
         balance -= amount;
      }else {
         double needs = amount - balance;
         throw new InsufficientFundsException(needs);
      }
   }
   
   public double getBalance() {
      return balance;
   }
   
   public int getNumber() {
      return number;
   }
}

Следующая программа Bank демонстрирует вызов методов deposit() и withdraw() класса Checking.

// Название файла Bank.java
public class Bank {

   public static void main(String [] args) {
      Checking c = new Checking(101);
      System.out.println("Депозит $300...");
      c.deposit(300.00);
      
      try {
         System.out.println("nСнятие $100...");
         c.withdraw(100.00);
         System.out.println("nСнятие $400...");
         c.withdraw(400.00);
      }catch(InsufficientFundsException e) {
         System.out.println("Извините, но у Вас $" + e.getAmount());
         e.printStackTrace();
      }
   }
}

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

Депозит $300...

Снятие $100...

Снятие $400...
Извините, но у Вас $200.0
InsufficientFundsException
         at Checking.withdraw(Checking.java:25)
         at Bank.main(Bank.java:13)

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

В Java можно выделить две категории исключений и ошибок.

  • Исключения JVM – данная группа представлена исключениями/ошибками, которые вызываются непосредственно и логически со стороны JVM. Примеры: NullPointerException, ArrayIndexOutOfBoundsException, ClassCastException.
  • Программные исключения – данные исключения вызываются непосредственно приложением либо программистами API. Примеры: IllegalArgumentException, IllegalStateException.
Источник

Понравилась статья? Поделить с друзьями:

Читайте также:

  • Ошибки canon mg3040
  • Ошибки hyundai solaris 2019
  • Ошибки hw antminer l3
  • Ошибки html кода как исправить
  • Ошибки canon mg2540s мигание

    • 0 0 голоса
    Рейтинг статьи
    Подписаться
    Уведомить о
    guest

    0 комментариев
    Старые
    Новые Популярные
    Межтекстовые Отзывы
    Посмотреть все комментарии