Я замечаю, что ряд классов исключений Java отличаются только именем класса и не добавляют никаких новых функций. Большинство исключений, например, просто переопределяют Exception() or Exception(String message). Это противоречит принципам наследования, т.е.: - наследовать, чтобы добавить функциональность new.
Каковы веские причины для создания нового класса Exception?
Исключения - это особый случай. В их случае наследование не должно добавлять новые функции, а добавлять новые классы ошибок. Это позволяет вашему коду захватывать определенные типы ошибок, игнорируя другие.
Скажите, что вы пишете большой проект. У вас есть компонент данных, и у вас есть компонент Display. Они могут терпеть неудачу разными способами, и вы хотите бросить исключения для этих сбоев. Однако компонент Display не заботится об исключениях, возникающих из компонента Data, и наоборот. Если бы все классы просто бросили Exception, не было бы возможности выяснить, откуда взялось исключение. Однако, если вы подклассифицируете Exception с помощью DataException и GraphicsException, даже если они не добавляют новых функциональных возможностей, теперь вы можете перехватывать и улавливать те конкретные типы исключений, то есть графический компонент может ловить GraphicsException, а не должны иметь дело с исключениями данных.
Вы можете перехватывать исключения по типу и исключение определенного типа, которое в остальном идентично базовому классу Exception, позволяет вам быть точным в обработке исключений.
Я бы сказал, что он добавляет новые функции напрямую, увеличивая специфичность кода обработки исключений.
Используйте новый тип исключения, если вы хотите предоставить обработку ошибок для определенного условия. Взгляните на java.io.IOException, и вы увидите следующие подклассы:
ChangedCharSetException
CharacterCodingException
CharConversionException
ClosedChannelException
EOFException
FileLockInterruptionException
FileNotFoundException
FilerException
HttpRetryException
IIOException
InterruptedIOException
InvalidPropertiesFormatException
JMXProviderException
JMXServerErrorException
MalformedURLException
ObjectStreamException
ProtocolException
RemoteException
SaslException
SocketException
SSLException
SyncFailedException
UnknownHostException
UnknownServiceException
UnsupportedDataTypeException
UnsupportedEncodingException
UTFDataFormatException
ZipException
Предположим, вы хотите прочитать из файла, вы можете получить общее IOException, исключение FileNotFoundException и исключение EOFException. Вы можете обращаться с каждым из этих случаев по-разному. Если бы все, что у вас было, было IOException, вам нужно было бы сделать что-то вроде просмотра сообщения об ошибке, а затем выполнить оператор if/else, чтобы выяснить, что такое фактическая ошибка, чтобы вы могли отобразить разумное сообщение пользователю. С иерархией исключений вы можете справиться с этими ситуациями намного проще.
В этом случае функциональность, которую добавляет наследование, относится к оператору catch, который может различать по типу. Обычно различение подклассов по типу считается плохой практикой, но обработка исключений - это исключение.
Это определенно приводит к нечетным ситуациям (таким как несколько операторов catch, которые имеют одинаковую логику), как вы ожидали бы, когда вещи различаются по типу, но это ограничение языка.
Я бы рекомендовал прочитать все или большую часть главы 9 Эффективная Java. В частности, пункт 60: "Способствовать использованию стандартных исключений" и Пункт 61: "Выбросить исключения, соответствующие абстракции".
EDIT 1: Или Элементы 42 и 43 в первом выпуске.
Если вам нужно или хотите отличить конкретную ситуацию ошибки от других ошибок в коде, тогда имеет смысл подклассифицировать соответствующее исключение. Вам не нужно заглядывать в сообщение об ошибке, чтобы определить, что пошло не так - это только для глаз человека.
Также обратите внимание, что правильно названное исключение может быть достаточно для глаз наблюдателей, чтобы определить, что пошло не так, когда нужно диагностировать трассировку стека. Типичным примером является ArrayOutOfBoundsException.
Это переименование происходит для устранения двусмысленности. произошла ошибка. например.
Foo getFoo() throws FooNotFoundException
будет явным, указывая на то, что a Foo не может быть найдено, в отличие от (какого?) некоторого незаконного состояния или ошибки подключения к базе данных или аналогичного, и вы можете выбрать код (или нет) для этой конкретной ошибки, Если вы решите бросить более общее исключение, это менее ясное (программно) то, что произошло.
Это плохая форма, чтобы просто поймать какое-либо исключение, потому что вы не только не знаете, откуда она взялась, но вы можете не допустить, чтобы вы правильно обрабатывали ошибки, когда они происходят. Если вы просто поймаете какое-либо исключение типа и обрабатываете его одним и тем же общим способом, вы можете скрывать другие проблемы в своем программном обеспечении или даже вводить новые. Итак, технически говоря, подклассификация Exception добавляет новые функции.
Вы добавляете новый класс исключений, когда пользователю вашего API может потребоваться его улов условно (или для проверенных исключений указать разные, конкретных типов в throws).
Создание исключения для любого типа действительно глупо. Возможно, вы должны создать исключение для другого уровня (DAO, Service и т.д.) Или другое действие (создать запись, дублировать запись и т.д.).