java.lang.Exception vs. rolar seus próprios exceção

StackOverflow https://stackoverflow.com/questions/237585

Pergunta

Em que ponto você criar sua própria classe de exceção vs. usando java.lang.Exception? (Todo o tempo? Só se ele vai ser usado fora do pacote? Só se ele deve conter lógica avançada? Etc ...)

Foi útil?

Solução

Eu acho que você precisa perguntar a si mesmo uma pergunta slighly diferente "Que vantagem é que a criação de uma nova exceção de mim ou desenvolvedores que usam o meu código de dar?" Realmente a única vantagem que lhe dá ou outras pessoas é a capacidade de lidar com a exceção. Que parece ser uma resposta óbvia, mas realmente não é. Você só deve ser lidar com exceções que você pode razoavelmente recuperar. Se a exceção você joga é um erro realmente fatal por dar aos desenvolvedores uma chance de mis-handle-lo?

discussão mais aprofundada: exceções personalizadas:? Quando você deve criá-los

Outras dicas

Motivo um:

Necessidade de material captura específico. Se chamando necessidades de código para lidar com uma condição excepcional específica, é preciso diferenciar a sua exceção, e Java diferencia exceções com diferentes tipos, por isso, você precisa escrever o seu próprio.

Basicamente, se alguém tem que escrever: 

catch(ExistingException e) {
  if({condition}) {
    { some stuff here}
  }
  else {
    { different stuff here}
  }
}

Você provavelmente vai querer escrever uma extensão específica; correspondência captura de exceção é mais clara do que condicionais, IMHO.

Lembre-se: seu novo Exceção pode ser uma subclasse de RuntimeException

Motivo dois:

consolidação API. Se você escrever uma interface e você tem várias implementações, é possível que eles vão chamar diferentes APIs com um monte de diferentes não-RuntimeExceptions jogado: 

interface MyInterface {
  void methodA();
}

class MyImplA {
  void methodA() throws SQLException { ... }
}

class MyImplB {
  void methodA() throws IOException { ... }
}

Você realmente quer MyInterface.methodA para jogar SQLException e IOException? Talvez então faz sentido para embrulhar as possíveis exceções em uma exceção personalizada. Que por sua vez pode ser uma RuntimeException. Ou até mesmo a própria RuntimeException ...

Eu acredito que: 

catch (Exception e) {
   ...
}

... é um antipattern que deve ser evitado. Você pode querer um centralizado ampla em algum lugar captura em seu aplicativo, para registrar um erro e evitar toda a aplicação de terminar -. Mas tê-los espalhados ao redor, querendo ou não é mau

Por: 

try {
   if(myShape.isHidden()) {
      throw new Exception();
   }
   // More logic
} catch (Exception e) {
   MyApp.notify("Can't munge a hidden shape");
}

Assim que você tentar isso, e devido a um erro de codificação, myShape é nulo. A NullPointerException é jogado quando as tentativas de tempo de execução para derefence myShape. Este código relata uma forma oculta, quando deve ser relatando um ponteiro nulo.

Quer fazer sua própria exceção, ou encontrar uma exceção adequadamente especializada na API. Não é como se estendendo Exception ou RuntimeException é onerosa.

Quando eu quero tratar meus exceções de forma diferente de todos os demais. Se eu quiser pegar o meu e de propagar todos os outros, ou se eu quiser pegar de outra pessoa e os meus propagar, ou se eu quiser pegar ambos, mas tratá-los de forma diferente, então eu vou definir uma classe separada para os meus exceções. Se eu quiser tratá-los todos a mesma, quer por propagação ambos ou pela captura de ambos (e fazendo a mesma coisa de qualquer forma com as exceções capturadas), o I usará a classe padrão.

Se houver uma exceção existente com o tempo de execução idioma ou bibliotecas, usá-lo MAIS criar seus próprios, documento-lo bem e que deve funcionar em 99% dos casos.

software captura significado.

Quase não há razões para lançar uma exceção existente: a JVM já faz isso para você. Sua versão de sua exceção não é realmente precisa e jogando "Exception" não é significativo, quer.

Você pode ter um DataFormatException por causa de um algoritmo de análise que você escreveu. Isso, no entanto, é raro.

Quando o programa encontra uma situação excepcional, é quase sempre exclusivo para o seu programa. Por força-caber sua situação excepcional em uma exceção existente? Se é exclusivo para o seu programa, então ... bem ... ele é único. Nomeá-lo dessa forma.

Do not, no entanto, fornecer uma classe de exceção única para cada mensagem única. Uma exceção class pode ter muitas mensagens variantes e detalhes de apoio.

A regra de ouro Python, traduzidos para Java, é definir todas as exceções únicas no nível do pacote. [Em Python, eles sugerem exceções no nível de "módulo", algo que não se traduz precisamente para Java.]

Iniciar sempre usando as classes de exceção comum e então, quando a necessidade surge para lidar com isso especialmente, alterá-lo.

  1. Ao criar um método primeira vez, deixe exceções passar.

  2. Se há exceções que devem ser manuseadas, aqueles podem ser apenas definido em lances ou envolvidos em alguma exceção tempo de execução ou envolto própria lança exceção. Eu prefiro exceções de tempo de execução em muitos casos. Definindo joga definição deve ser evitado até que haja uma necessidade para ele do ponto de vista API.

  3. Mais tarde, quando a necessidade aparece para fazer tratamento específico para uma exceção em algumas chamadas, voltar e criar uma nova exceção para ele.

O ponto é evitar fazer trabalho extra antes de saber o que é necessário.

Eu não posso imaginar especificamente jogando um java.lang.Exception se algum objeto / classe / método teve um problema. É muito genérico -. Se você não está indo para criar sua própria classe de exceção, parece-me que não deveria ser pelo menos um tipo de exceção mais específico na API

Gostaria de usar as exceções da API Java quando a exceção se relaciona com a API. Mas se uma situação excepcional surge que é exclusivo para a minha própria API, então vou criar uma exceção para ele. Por exemplo, se eu têm um objecto Range com duas propriedades mínimo e máximo e o mínimo invariante <= max então irá criar uma InvalidRangeException excepção.

Quando estou escrevendo código que isso ajude, porque eu sei que se provém de exceção, porque eu violou uma das minhas próprias condições ou o seu algo a partir da API Java.

Na maioria dos casos não faz sentido criar sua própria classe de exceção.

Há uma tendência em programadores iniciantes para criar sua própria classe de exceção só assim eles podem usar um nome que é mais indicativo do tipo de erro. Então você vai encontrar aulas como FTPInitializationException, DAOFactoryException etc. mesmo que essas excepções não estão sendo tratados de forma diferente do que exceções padrão. Este é claramente um padrão de anti que deve ser evitado.

Licenciado em: CC-BY-SA com atribuição
Não afiliado a StackOverflow
scroll top