Excepciones y manejo de excepciones

En primer lugar, el concepto de excepciones

1. definición:

   Se refiere a la ejecución de error se produce anormal, lo que está mal en el futuro cuando el programa se inicia período de ejecución se plantea.

2. El procesamiento de actitud:

       Cuando excepción capturada será fácil llegar a un acuerdo, incluso si se trata de una excepción a este mensaje de error impreso, esto es una buena práctica de programación.
       Si no se ocupan de que es para ocultar el error en voz baja, pero todavía existe el error, pero no puede verlo. Esta es una práctica de programación muy peligroso, absolutamente no puede hacer eso, tiene que haber una excepción a la captura de llegar a un acuerdo, que no puede manejar para poner produce una excepción, por lo que otros métodos de tratar. De todos modos, no puede ser capturado después de una anormal, pero no hacen el tratamiento adecuado, lo cual es una práctica muy mala programación.

En segundo lugar, la clasificación malfuncionamiento

1. Excepción manera Manipulación:

       Utilice la declaración del método lanza una excepción lanzada: un método
           lanza Excepción
               clase de excepción es la clase base para todas las clases de excepción pueden manejar, lanza clase de excepciones arrojará todas las clases de excepción pueden ser procesados en el.
       Método dos: manual de tirar
           lanzamiento + excepción objeto
               objeto excepción lanzada hacia fuera, y entonces el tipo de declaración sobre el método de escritura a lanzar excepciones.
       Método tres:
           el try ... cacth un último ...

        try {
			//处理业务代码
		} catch (Exception e) {
			//抛出异常处理，具体异常具体定
			e.printStackTrace();
		} finally{
			//最终都需执行的代码
			//一般做资源清理工作
		}

       Generalmente usamos el método printStackTrace () para imprimir esta información anormal, utilice este método para imprimir toda la información equivocada, incluida la información sobre el uso del método getMessage () para imprimir. Para un nuevo objeto de error de llamarlo a cabo antes de utilizar este método. Debido a que es específica para un objeto de error dentro del método.

2. Cinco claves manejo de excepciones de Java: try, catch, por último, a un tiro, lanza

3. Mal funcionamiento de clasificación
   
   código de ejemplo:

package com.lixu.javabase.exception;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

/**
 * 异常Demo
 */
public class ExceptionDemo {
	
	/**
	 * 任何方法往外抛能处理的异常的时候都有一种简单的写法：“throws Exception”
	 * 因为Exception类是所有能处理的异常类的根基类，因此抛出Exception类就会抛出所有能够被处理的异常类里了。
	 * 使用“throws Exception”抛出所有能被处理的异常之后，这些被抛出来的异常就是交给JAVA运行时系统处理了，
	 * 而处理的方法是把这些异常的相关错误堆栈信息全部打印出来。
	 */
	void mothod() throws Exception{
		
	}
	
	
	public void method1() throws Exception{
		//不处理，可能产生FileNotFoundException异常
		@SuppressWarnings("resource")
		FileInputStream flStream = new FileInputStream("mytext.txt");
		//这里有可能会产生IOException异常
	    int b = flStream.read();
	    while (b != -1) {
	          System.out.println((char)b);
	          b = flStream.read();
        }
	}

	public void method2() throws FileNotFoundException,IOException {
		@SuppressWarnings("resource")
		FileInputStream flStream = new FileInputStream("mytext.txt");
		int b = flStream.read();
		while (b != -1) {
	          System.out.println((char)b);
	          b = flStream.read();
      }
	}
	
	public void method3(){
		FileInputStream flStream = null;
		try {
			flStream = new FileInputStream("mytext.txt");
			int b = flStream.read();
			while(b != -1){
				System.out.println((char)b);
		        b = flStream.read();
			}
		} catch (FileNotFoundException e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		} catch (IOException e){
			System.out.println(e.getMessage());
		} finally{
			try {
              /**
              * 前面已经把一个文件打开了，不管打开这个文件时有没有错误发生，即有没有产生异常，最后都一定要把这个文件关闭掉，
              * 因此使用了finally语句，在finally语句里面不管前面这个文件打开时是否产生异常，在finally这里执行in.close()都能把这个文件关闭掉，
              * 关闭文件也有可能会产生异常，因此在finally里面也使用了try……catch语句去捕获有可能产生的异常。
              */
			  flStream.close();
			} catch(Exception e){
			  e.printStackTrace();
			}				          
		}		
	}
	
}

En tercer lugar, excepción personalizada

package com.lixu.javabase.exception;


/**
 * 自定义异常MyException
 */
public class MyException extends Exception {

	private int id;
	
	/**
	 * 自定义异常类的构造方法
	 * @param message
     * @param id
     */
	public MyException(String message,int id) {
		super(message);
		this.id = id;
	}
	
	/**
	 * 获取异常的代码
	 * @return
	 */
	public int getId() {
		return id;
	}
		
}

excepciones de prueba definidos

package com.lixu.javabase.exception;

import java.text.MessageFormat;

public class TestMyException {

	public static void main(String[] args){
		TestMyException tmException = new TestMyException();
		tmException.manage();
	}
	
	//throws MyException,抛出我们自定义的MyException类的异常。
	public void regiter(int num) throws MyException{
		if(num < 0){
			//使用throw手动抛出一个MyException类的异常对象。
			throw new MyException("人数为负值，不合理", 1);
		}
		System.out.println(MessageFormat.format("登记人数：{0}",num));
	}
	
	public void manage() {
         try {
             regiter(-100);
         } catch (MyException e) {
             System.out.println("登记失败，错误码："+e.getId());
             e.printStackTrace();
         }
         System.out.println("操作结束");
    }
}

En cuarto lugar, el manejo de excepciones Resumen

de referencia: https: //www.cnblogs.com/xdp-gacl/p/3627390.html