Java基础--异常处理

异常

//异常分为：编译异常（parvseException）必须处理
//        :运行异常（Runtime Exception）不用处理
/**try{
 * 一旦try里除了问题，就会把异常抛出去，然后与catch里的问题匹配
 *         try里的代码越少越好；
 * }catch(异常变量){
 *     里面必须有内容，至少一个提示，针对问题的处理
 * }
 * catch(){
 * Exception放在后面；
 * }
 * finally{
 * 释放资源
 * }
 * 
 *finally:被Finally控制的语句体一定会执行，但是如果在执行前退出虚拟机    Jvm (system.exit)
 *         不执行；
 *        作用：用于释放资源在Io流与数据库中常用； 
 * throws与thow的区别；
 * throws:在方法体后跟异常类名；可以跟多个异常类用逗号隔开，表示可能有异常出现。
 * throw:在方法体内，跟的是异常对象名，只可抛出一个异常对象名，表示抛出异常，
 *       由方法体内的语句处理。throw是抛出异常，执行throw则一定抛出了某种异常。
 *       如果有异常抛出的是异常对象所以要New,
 * 可以处理的异常用try{}语句，后续程序要继续运行就try;那么处理的对象一定要初始化将他为null
 * 不可以处理的异常throws后续程序不继续运行就throws
 * 
 */
public class Exeption1 {
	public static void main(String[] args) {
		Scanner can=new Scanner(System.in);
	
		 try{
			 //动作触发机制
			 int input=can.nextInt();
			 System.out.println("请输入被除数：");
			 int input1=can.nextInt();
			 System.out.println("请输入除数");
			 System.out.println(input/input1+"="+"input"+"/"+"input1");
		 }catch(ArithmeticException a){//异常处理程序
		        System.err.println("除数不可以为0");
		        System.err.println(a.getMessage());
		        
		 }catch(InputMismatchException in){
			 System.err.println("请输入数字");
			 System.out.println(in.getStackTrace());
			
		 }catch(Exception e){
			 e.getStackTrace();
		 }finally{
			 System.out.println("谢谢使用");
			 System.out.println("程序运行完毕");
		 }
			 /*异常处理理论的两种基本类型：
			  * 终止模型：错误抛出无法挽回，不能回来继续执行
			  * 恢复模型：异常处理程序的工作是修正错误，异常处理后可以继续执行程序。 不实用 它导致了耦合
			  * 异常输出System.err()是因为不会随System.out一起被重定向，
		
			  * */
		 }
}		
	

自定义异常

/***
 * 自定义异常 需要继承Exception 或 Exception的子类 构造方法可以是无参数和有参数的方法
 * 
 * 
 * 
 * **/
public class DivideZeroException extends ArithmeticException { // 自定义异常类
	public DivideZeroException() {
	} // 实现默认构造方法

	public DivideZeroException(String msg) {
		super(msg);
	} // 实现有输出信息的构造方法
}

try…catch…finally

/**
 * try....catch....finally
 * 捕获异常
 * try 是问题的代码
 * catch 是异常 可以多个
 * finally:无论发生否异常都会执行
 * 
 * 捕获异常是开销比较大，try里的语句尽量减少些
 * ***/
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class CatchExceptionsOnes {
    private static String URL = "jdbc:mysql://localhost:3306/db_database";
    private static String DRIVER = "com.mysql.jdbc.Driver";
    private static String USERNAME = "mr";
    private static String PASSWORD = "mingri";
    private static Connection conn;
    public static Connection getConnection() {
        try {
            Class.forName(DRIVER);// 加载驱动程序
            conn = DriverManager.getConnection(URL, USERNAME, PASSWORD);// 建立连接
            return conn;
        } catch (ClassNotFoundException e) {// 捕获类为发现异常
            e.printStackTrace();
        } catch (SQLException e) {// 捕获SQL异常
            e.printStackTrace();
        }
        return null;
    }
    public static void main(String[] args) {
        CatchExceptions捕获多个.getConnection();
    }
}

/**
 * try....catch....finally
 * 捕获异常
 * try 是问题的代码
 * catch 是异常
 * finally:无论发生否异常都会执行
 * 
 * 捕获异常是开销比较大，try里的语句尽量减少些
 * ***/
public class CatchExceptionOne {
    public static void main(String[] args) {
        try {											// 定义try语句块
            System.out.println("进入try语句块");
            @SuppressWarnings("unused")//告诉它对被批注的代码元素内部的某些警告保持静默。 批注允许您选择性地取消特定代码段（即，类或方法）中的警告。其中的想法是当您看到警告时，
                                       //您将调查它，如果您确定它不是问题，您就可以添加一个 @SuppressWarnings 批注，以使您不会再看到警告。
                                       //虽然它听起来似乎会屏蔽潜在的错误，但实际上它将提高代码安全性，因为它将防止您对警告无动于衷 — 您看到的每一个警告都将值得注意。
            Class<?> clazz = Class.forName("");			// 得到一个空的Class对象
            System.out.println("离开try语句块");
        } catch (ClassNotFoundException e) {				// 定义catch语句块
            System.out.println("进入catch语句块");
            e.printStackTrace();
            System.out.println("离开catch语句块");
        } finally {										// 定义finally语句块
            System.out.println("进入finally语句块");
        }
    }
}

算数异常

/**
 *   ArithmeticException 算数异常
 * 由于第二条可能出现异常的语句没有捕获，在发生异常时，程序终止了。所有最后一条语句并没有被输出
 *      何时抛出算术异常：在系统检测到整数被0出的情况下，它将构造一个新的异常对象，然后引发异常，导致后面的语句不会被执行
 *                          也就终止了程序的执行
 *                          
 *        try.....catch语句捕获异常，并进行处理，这样不影响后面的语句执行
 *  在Java的异常处理机制中，有一个默认处理异常的程序，当程序出现异常时，默认处理程序将显示一个描述异常的字符串，打印异常发生处的堆栈轨迹，并终止程序          
 * ***/
public class ExceptionTest算数异常 {
    public static void main(String[] args) {
        System.out.println("-1.0 / 0 = " + (-1.0 / 0));// 演示负浮点数除0
        System.out.println("+1.0 / 0 = " + (+1.0 / 0));// 演示正浮点数除0
        try{
        	System.out.println("-1 / 0 = " + (-1 / 0));// 演示负整数除0
        }catch(Exception e){
        	System.out.println("抛出异常："+e.getMessage());
        }
      //  System.out.println("+1 / 0 = " + (+1 / 0));// 演示正整数除0
        System.out.println("输出结束。");
    }
}

数组下标越界异常

/**
 * ArrayIndexOutOfBoundsException
 * 数组元素的下标值大于等于数组的长度时发生
 * 在遍历数组中的全部元素，推荐foreach循环,他可以避免数组的下标越界，如果要使用数组的下标，则需要记住数组的下标是从开始计算的，
 *   需要使用数组的长度，则推荐使用length属性，另外使用ArrayList类也可以避免这些问题
 * 
 * 
 * 
 * 
 * **/
import java.util.Arrays;

public class ArrayExceptionTest {
	/** public static void fill(Object[] a,  int fromIndex,  int toIndex,   Object val)
	 * 将指定的 Object 引用分配给指定 Object 数组指定范围中的每个元素。
	 * 填充的范围从索引 fromIndex（包括）一直到索引 toIndex（不包括）。（如果 fromIndex==toIndex，则填充范围为空。） 
	 *         a - 要填充的数组
       fromIndex - 要使用指定值填充的第一个元素的索引（包括）
       toIndex - 要使用指定值填充的最后一个元素的索引（不包括）
           val - 要存储在数组的所有元素中的值
	 * 抛出： 
		IllegalArgumentException (非法访问异常)- 如果 fromIndex > toIndex 
		ArrayIndexOutOfBoundsException(数组下标越界) - 如果 fromIndex < 0 或 toIndex > a.length 
		ArrayStoreException - 如果指定值不是可存储在指定数组中的运行时类型
*第一个参数指操作的数组，第二个和第三个指在该数组的某个区域内插入第四个参数，
                                     一定要注意:1.Java的数组下标从0开始
                     2.第二个参数指起始元素下标(包括该下标)
                     3.第三个参数指结束下标(不包括该下标

*	 */
	public static void main(String[] args) {
		int[] array = new int[5]; // 声明一个长度为5的整型数组
		Arrays.fill(array,2,7, 0); // 将新声明的数组所有元素赋值为8
		for (int i = 0; i < 4; i++) {// 遍历输出所有数组元素
			System.out.println("array[" + i + "] = " + array[i]);
		}
	}
}

文件未发现异常

/***
 * FileNotFoundException 
 *     试图打开指定路径名表示的文件失败是抛出，在不存在具有指定路径名的文件是
 *       此异常将由FileInputStream,FileOutputStream,RandomAccessFile构造方法抛出，
 *       如果该文件存在，但是一些原因不可访问，例如试图打开一个只读文件进行写入，则此时这些构造方法仍然会抛出该异常
 * 
 * 
 * 
 * **/
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class FileNotFoundE{
	
    public static void main(String[] args) {
        FileInputStream fis = null;// 创建一个文件输入流对象
        try {
            File file = new File("d:\\kira.txt");// 创建一个文件对象
            fis = new FileInputStream(file);// 初始化文件输入流对象
        } catch (FileNotFoundException e) {// 捕获异常
            e.printStackTrace();
        } finally {
            try {
                fis.close();// 释放资源
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

非法访问异常

/****
 * IllegalAccessException非法访问异常
 *    不容许访问末类是发生，
 * 是在 程序试图
 *    反射性地创建一个实例(而不是数组),设置或获取一个字段,或者调用一个方法时，并且当前正在执行的方法无法访问指定类，
 *    字段，方法或者构造方法的
 *       定义是抛出异常
 *       
 * 
 * 
 * 
 * **/
import java.lang.reflect.Field;

public class IllegalAccessE非法访问异常 {
    public static void main(String[] args) {
        Class<?> clazz = String.class;						//获得代表String类的类对象
        Field[] fields = clazz.getDeclaredFields();				//获得String类的所有域
        for (Field field : fields) {							//遍历所有域
            if (field.getName().equals("hash")) {				//如果域的名字是hash
                try {
                    System.out.println(field.getInt("hash"));	// 输出hash的值
                } catch (IllegalArgumentException e) {		//捕获IllegalArgumentException异常
                    e.printStackTrace();
                } catch (IllegalAccessException e) {			//捕获IllegalAccessException异常
                    e.printStackTrace();
                }
            }
        }
    }
}

throw关键字

/**
 * throw关键字在方法中抛出异常，使用throw关键字可以在方法体重抛出异常，该异常可以是系统预定义异常，
 * 也可以是用户自定义异常，格式：throw异常对象
 * throw关键字可以抛出一个异常对象，并且仅可以应用在方法体中
 * 
 * ***/
public class ThrowException方法体内抛异常 {
    public static void throwException() {
        throw new UnsupportedOperationException("方法尚未实现");		// 在方法体内抛出异常
    }
    public static void main(String[] args) {
        ThrowException方法体内抛异常.throwException();							// 调用抛出异常的方法
    }
}

/**
 * throws 关键字
 *     可以在方法体外抛出异常，该异常既可以是系统预定义异常,有可以是用户自定义异常，
 *                 可以声明抛出多个异常，并且尽可以应用在方法体外
 * **/
public class ThrowsException方法体外抛异常 {
    public static void throwsException() throws ClassNotFoundException {// 抛出异常
        Class.forName("com.mysql.jdbc.Driver");
    }
    
    public static void main(String[] args) {
        try {// 捕获异常
            ThrowsException方法体外抛异常.throwsException();// 调用抛出异常的方法
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

Logger 日志

public class Logger2 {

	  private static Logger logger =
		    Logger.getLogger("Logger2");
	  //静态的Logger.getLogger()方法创建了一个String参数相关联的Logger对象。
	  //这个Logger对象会将其输出发送到System,err，向Logger希尔的最简单方式就是直接调用与日志记录消息的级别相关联的方法
		  static void logException(Exception e) {
		    StringWriter trace = new StringWriter();
		    e.printStackTrace(new PrintWriter(trace));
		    logger.severe(trace.toString());
		  }
		  public static void main(String[] args) {
		    try {
		      throw new NullPointerException();
		    } catch(NullPointerException e) {
		      logException(e);
		    }
		  }
		}

class LoggerExceptions extends Exception {

	  private static Logger logger =
		    Logger.getLogger("Logger异常日志");
		  public LoggerExceptions() {
		    StringWriter trace = new StringWriter();
		    printStackTrace(new PrintWriter(trace));
		    logger.severe(trace.toString());
		  }
		}
public class Logger异常日志  {//public类必须有在家的Java文件 
	  public static void main(String[] args) {
	    try {
	      throw new LoggerExceptions();
	    } catch(LoggerExceptions e) {
	      System.err.println("Caught " + e);
	    }
	    try {
	      throw new LoggerExceptions();
	    } catch(LoggerExceptions e) {
	      System.err.println("Caught " + e);
	    }
	  }
	}