No idioma java, a classe base da classe de erro é java.lang.error, e a classe base da classe de exceção é java.lang.Exception.
1) semelhanças: java.lang.error e java.lang.Exception são subclasses de java.lang.THOWLABLE, então java.lang.error e java.lang.Exception e suas subclasses podem ser usadas como objetos de arremesso, como: lança nova (); e jogue nova myException (); Onde, a classe MyError é uma subclasse de java.lang.error, e a classe MyException é uma subclasse de java.lang.Exception.
2) Diferenças: Java.Lang.Error e suas subclasses não exigem o suporte da instrução Try-Catch. O método pode ser retornado a qualquer momento, conforme definido pelo seguinte método:
public string myMethod () {tiro new MyError (); } Onde a classe MyError é uma subclasse da classe java.lang.error.
Java.lang.Exception A própria e suas subclasses precisam do suporte de declarações de tentativa de captura, e a definição do método a seguir está errada:
public string myMethod () {throw new MyException (); }O método correto é definido da seguinte forma:
public string myMethod () lança myException {tiro new MyException (); }Onde a classe MyException é uma subclasse de java.lang.Exception.
A exceção do Java é um objeto criado quando uma situação anormal é encontrada quando um programa Java está em execução. Ele encapsula informações de exceção. A classe raiz da exceção java é java.lang.THOWLABLE. Toda a classe possui duas subclasses diretas java.lang.error e java.lang.exception.error é um erro grave que não pode ser recuperado pelo próprio programa. A exceção indica um erro de exceção que pode ser capturado e processado pelo programa. A JVM usa a pilha de chamadas do método para rastrear uma série de processos de chamada de método em cada thread, que salva as informações locais de cada método de chamada. Para programas Java independentes, ele pode até o método principal do programa. Quando um novo método é chamado, a JVM coloca a estrutura da pilha que descreve o método na parte superior da pilha, e o método na parte superior da pilha é o método de execução correto. Quando A J após o método AVA ser executado normalmente, a JVM retorna à estrutura da pilha do método da pilha de chamadas e continua a processar o método anterior. Se o método Java lançar uma exceção durante a execução do código, a JVM deverá encontrar o código do bloco de captura que pode capturar a exceção. Primeiro, ele verifica se o método atual possui um bloco de código de captura e, se existir, execute o bloco de código de captura. Caso contrário, a JVM retorna à estrutura da pilha do método na pilha de chamadas e continua a encontrar o bloco de código de captura apropriado no método anterior. Finalmente, se a JVM perseguir o método Main (), ou seja, continua lançando a exceção ao método Main () e ainda não encontrou o bloco de código para o manipulador de exceção, o thread terminará de forma anormal. Se o thread for o encadeamento principal, o aplicativo também será encerrado de acordo. Neste momento, a JVM lançará a exceção diretamente ao usuário e as informações de exceção original serão vistas no terminal do usuário.
Java.lang. Análise de código -fonte abrangente
pacote java.lang; importar java.io.*; /** * * Throwable is the parent class of all Error and Exceptiong* Note that it has four constructors: * Throwable() * Throwable(String message) * Throwable(Throwable cause) * Throwable(String message, Throwable cause) * */ public class Throwable implements Serializable { private static final long serialVersionUID = -3042686055658047285L; /*** O código nativo economiza alguma indicação do backtrace da pilha neste slot. */ backtrace de objeto transitório privado; / *** Informações descrevendo esta exceção*/ private String detalhetMessage; / *** Indica que a exceção atual é causada pelo arremesso* Se nulo significa que a exceção não é causada por outros jogáveis* Se esse objeto for o mesmo que ele, indica que o objeto que causa a exceção não foi inicializado*/ Causa de lançamento privado = this; / *** Array descrevendo a faixa de exceção*/ private StacktraceElement [] Stacktrace; / *** Construtor, o objeto de causa não é inicializado pode ser inicializado no futuro usando initcause* FillInstackTrace pode ser usado para inicializar uma matriz de suas faixas de exceção*/ public Throwable () {FillInstackTrace (); } /** // Inicialize a exceção Descrição Informações Detalhes Message = Mensagem; } /** detalheMessage = mensagem; this.cause = causa; } /** detalheMessage = (causa == null? null: caus.ToString ()); this.cause = causa; } / *** Obtenha informações detalhadas* / public string getMessage () {return detalheDMessage; } / *** Obtenha informações detalhadas* / public string getLocalizedMessage () {return getMessage (); } / *** Obtenha o objeto de causa* / public the Throwable getCause () {return (causa == this? Null: causa); } /*** Inicialize o objeto de causa. Esse método só pode ser chamado uma vez sem inicialização*/ public syncronizado Initcause (causa lançável) {// Se não for um estado não inicializado, jogue uma exceção se (this.cause! = This) lançar uma nova estate -texcepção ilegal ("não pode substituir a causa"); // O objeto de causa é definido é igual a si mesmo e jogue uma exceção se (causar == isto) lançar uma nova ilegalArgumentException ("Autocução não permitida"); // defina o objeto de causa isto.cause = causa; // Retornar o conjunto de causar o objeto Retornar isso; } / *** Representação da String* / public string tostring () {string s = getClass (). GetName (); String message = getLocalizedMessage (); return (mensagem! = nulo)? (s + ":" + mensagem): s; } / *** Imprima a faixa de erro* / public void printStackTrace () {printStackTrace (System.err); } /*** Imprima a faixa de erro* /public void PrintStackTrace (PrintStream S) {sincronizado (s) {// chamando o método de tostring do objeto atual s.println (this); // Obtenha a excepcionária StackTraceElement da matriz de pista de exceção [] Trace = getourStackTrace (); // imprima a representação da string de cada elemento para (int i = 0; i <trace.length; i ++) s.println ("/tat"+trace [i]); // Obtenha o objeto de causa jogável OurCause = getCause (); // Imprima recursivamente as informações do objeto de causa se (OurCause! = NULL) OurCause.printStackTraceasCause (S, Trace); }} /*** Imprima a causa das informações do objeto* @param s // m é o último elemento da matriz de faixas de exceção atual, // n é o último elemento da matriz de pista de exceção da exceção causada pelo objeto atual int m = trace.Length-1, n = causoutrace.Length-1; // loop por trás das duas matrizes, respectivamente. Se for igual, loop até que a desigualdade ou a matriz atinja o começo enquanto (m> = 0 && n> = 0 && trace [m] .equals (causado [n])) {m--; n--; } // o mesmo número int fRamesincommon = trace.length - 1 - m; // imprima traços de erro diferentes s.println ("causados por:" + this); for (int i = 0; i <= m; i ++) s.println ("/tat"+rastreio [i]); // Se houver o mesmo número, imprima o mesmo número se (Framesincommon! = 0) s.println ("/t ..." + Framesincommon + "More"); // Obtenha a causa deste objeto e imprima as informações que lança recursivamente nossa base = getCausa (); if (OurCause! = NULL) OurCause.printStackTraceasCause (s, rastreio); } / *** Imprima a faixa de erro* / public void printStackTrace (printWriter s) {sincronizado (s) {s.println (this); StackTraceElement [] Trace = getourStackTrace (); for (int i = 0; i <trace.length; i ++) s.println ("/tat"+rastreio [i]); Arremesso de que nossa = getCausa (); if (OurCause! = NULL) OurCause.printStackTraceasCause (s, rastreio); }} / *** Imprima as informações sobre o objeto de causa* / private void PrintStackTraceasCause (PrintWriter s, StackTraceElement [] causoutrace) {// Assert Thread.holdSlock (s); // Calcule o número de quadros em comum entre isso e causou StacktraceElement [] Trace = getourStackTrace (); int m = trace.Length-1, n = causoutrace.Length-1; while (m> = 0 && n> = 0 && trace [m] .equals (causado [n])) {m--; n--; } int fRamesincommon = trace.length - 1 - m; s.println ("causado por:" + this); for (int i = 0; i <= m; i ++) s.println ("/tat"+rastreio [i]); if (Framesincommon! = 0) s.println ("/t ..." + FramesIncommon + "mais"); // Recurse se tivermos uma causa arremessada de nossascaus = getCausa (); if (OurCause! = NULL) OurCause.printStackTraceasCause (s, rastreio); } / *** Preencha a faixa de exceção* / public sincronizado nativo atirável FillInstackTrace (); / *** Retorne uma cópia da faixa de exceção atual*/ public StackTraceElement [] getStackTrace () {return (StackTraceElement []) getourStacktrace (). Clone (); } /** * Obtenha a faixa de exceção atual * /Sincronizado privado StackTraceElement [] getourStackTrace () {// Se esse método for chamado pela primeira vez, a matriz de faixa de exceção é inicializada se (StackTrace == NULL) {// Obtenha a exceção da profundidade da faixa de profundidade = getStacktrace (); // Crie uma nova matriz de faixas de exceção e preencha -a StackTrace = novo StackTraceElement [profundidade]; para (int i = 0; i <profundidade; i ++) Stacktrace [i] = getStackTraceElement (i); // Obtenha a faixa de exceção do ponto de bits especificado} retornar Stacktrace; } /*** Defina a faixa de exceção* /public void SetStackTrace (StackTraceElement [] StackTrace) {// copie o parâmetro de configuração StackTraceElement [] DefendensiveCopy = (StacktraceElement []) Stacktrace.clone (); // Se o parâmetro de configuração tiver elementos vazios, será lançada uma exceção para (int i = 0; i <defensivecopy.length; i ++) se (defensivecopy [i] == null) lançar nova nullpointerException ("Stacktrace [" + i + "]"); // Defina a faixa de exceção do objeto atual this.stackTrace = DefensiveCopy; } / ** * A profundidade da faixa de exceção, 0 significa que não é possível obter * / privado nativo int getStackTraceThTh (); / *** Obtenha a faixa de exceção do ponto de bit especificado*/ private nativo StackTraceElement getStackTraceElement (INT índice); private sincronizado void writeObject (java.io.ObjectOutputStream s) lança IoException {getourStackTrace (); s.defaultWriteObject (); }}