• 检查异常处理方式：1，抛出；2，捕获

    异常：Exception

    一、什么是异常

    我们的程序在运行过程中产生的一些问题,这些问题有的是编码错误，有的是用户不正当操作引起的，有的是外部物理设备引起的。

    二、异常的继承结构

    Throwable:可抛出的

    -->EXception:异常

    一般都是程序编写问题或用户不正当操作引起的，

    通过程序代码来进行解决

    ------>编译期异常(检查异常）

    程序在编译期间，由编译器检查出来的异常，必须要处理，否则编译不能通过

    如：ParseException

    ------>运行时异常(非检查异常）

    所有的运行时异常会继承自RuntimeException；

    运行时异常在编译期间检测不到，但是在运行期间有可能会报异常，可以不处理也可以处理

    如：ArratyIndexOutOfBoundException

    classcastException

    NUllPointException

    -->Error：错误

    一般是由物理设备引起的，无法通过代码来解决，一般我们不要处理

    StackoverFlowError:栈溢出错误

    OutOfMemoryError:堆内存溢出

    1. import java.io.FileInputStream;
    2. import java.io.FileNotFoundException;
    3. import java.text.ParseException;
    4. import java.text.SimpleDateFormat;
    5. import java.util.Date;
    6. import java.util.Scanner;
    7.  
    8. /*
    9.  * 检查异常处理方式：抛出
    10.  */
    11. public class TestException01 {
    12.     /**
    13.      * 调用m1()方法，因为m1()方法也没有处理异常，
    14.      * 所以main()方法看到的就是有异常的m1()方法
    15.      * main（）方法继续向上抛出异常，最终抛给了jvm虚拟机
    16.      * jvm打印出异常的堆栈信息
    17.      * 
    18.      * 客人：服务员将炒糊的菜端给了客人，客人看到的菜就是炒糊的菜
    19.      * @param args
    20.      * @throws Exception 
    21.      */
    22. 	
    23. 	public static void main(String[] args) throws Exception {
    24. 		//看到两个异常的m01()方法
    25. 		//客人看到的菜是既炒糊了，又没盐的
    26. 		
    27. 		//看到的就是只有一个父异常的m1()方法
    28. 		//客人也只知道才没炒好，不指定具体哪里没炒好
    29. 		//m01();
    30. 		m02();
    31. 	}
    32. 	/**
    33. 	 * 调用m0方法,因为m0中抛出异常，所以调用就是有异常的m0()方法
    34. 	 * 
    35. 	 * m1()可以选择继续向上抛出，谁来调用m1()这个方法就抛给谁
    36. 	 * 服务员：去取厨师炒的菜，看到就是炒糊的菜
    37. 	 * @throws Exception 
    38. 	 */
    39. 	public static void m1() throws Exception {
    40. 		//看到两个异常的m01()方法
    41. 		//服务员看到的菜是既炒糊了，又没盐的
    42. 		//m01();
    43. 		
    44. 		//服务员只知道菜没炒好，但不知道具体哪没炒好
    45. 		/*
    46. 		 * m1()只会看到父异常的Exception，不知道哪个没炒好
    47. 		 */
    48. 		m02();
    49. 	}
    50. 	
    51. 	/*
    52. 	 * 让用户控制台输入一个指定格式字符串
    53. 	 * 然后将这个字符串解析为日期对象
    54. 	 * 
    55. 	 * 异常：菜炒糊了
    56. 	 * 		：没放盐
    57. 	 * 		：油多了
    58. 	 * 抛出：不处理，向上抛出不管，
    59. 	 * 				谁来调用这个方法，谁处理
    60. 	 * @throws：ParseException
    61. 	 * @throws：FileNotFoundException
    62. 	 */
    63. 	
    64. 	
    65. 	public static void m01() throws ParseException, FileNotFoundException {
    66. 		System.out.println("请输入日期（yyyy-MM-dd)");
    67. 		
    68. 		String dateStr=new Scanner(System.in).nextLine();
    69. 		SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
    70. 		Date date =sdf.parse(dateStr);
    71. 		System.out.println("date="+date);
    72. 		
    73. 		//尝试去连接一个磁盘文件
    74. 		FileInputStream in=new FileInputStream ("D:/a.text");
    75. 	}
    76.  
    77. 	/*
    78. 	 * 让用户控制台输入一个指定格式字符串
    79. 	 * 然后将这个字符串解析为日期对象
    80. 	 * 
    81. 	 * 异常：菜炒糊了
    82. 	 * 		：没放盐
    83. 	 * 		：油多了
    84. 	 * 
    85. 	 *总问题：没炒好
    86. 	 * 抛出：不处理，向上抛出不管，
    87. 	 * 				谁来调用这个方法，谁处理
    88. 	 * 				抛出的是一个父类型的异常
    89. 	 * @throws：ParseException
    90. 	 * @throws：FileNotFoundException
    91. 	 */
    92. 	
    93. 	
    94. 	public static void m02() throws Exception {
    95. 		System.out.println("请输入日期（yyyy-MM-dd)");
    96. 		
    97. 		String dateStr=new Scanner(System.in).nextLine();
    98. 		SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
    99. 		Date date =sdf.parse(dateStr);
    100. 		System.out.println("date="+date);
    101. 		
    102. 		//尝试去连接一个磁盘文件
    103. 		FileInputStream in=new FileInputStream ("D:/a.text");
    104. 	}
    105. }

    2、捕获

    如果异常需要自己处理，也可以在方法内部通过try~catch 来对异常进行捕获并处理，那么方法调用者就不需要再去

    处理异常了

    语法：

    try{

    //有检查异常的代码块

    }catch（XXException e){

    //捕获异常并处理

    }catch（XXException e){

    //捕获异常并处理

    }。。。

    finally{

    //最终执行代码块。可以没有

    }

    注意：

    1》try中代码块出现了异常，那么跟在这一行的后面的try中代码都不执行

    2》finally为最终执行代码块，是必须要执行的，即使try或者catch中有return，也会先去执行finally中代码，再回去执行return

    3》如果有多个检查异常，catch可以有多个这些异常之间如果有父子关系，那么子类型必须写在父类型的上面，否则捕获不到或者通过一个catch类型捕获这多个异常的父类型异常

    4》如果有必须要执行的代码块，可以单独使用try和finally

    5》运行时异常通常不需要处理，

    如果要处理，也可以按照检查异常一样去处理

    1. import java.io.FileInputStream;
    2. import java.io.FileNotFoundException;
    3. import java.io.IOException;
    4. import java.text.ParseException;
    5. import java.text.SimpleDateFormat;
    6. import java.util.Date;
    7. import java.util.Scanner;
    8.  
    9. /**
    10.  * 异常处理方式：捕获
    11.  *
    12.  */
    13. public class TestException02 {
    14. 	public static void main(String[] args) {
    15. 		//客人看到的就是没有问题的菜
    16. 			m03();
    17. 	}
    18. 	
    19. 	/*
    20. 	 * 因为厨师自己处理了炒糊的菜
    21. 	 * 服务员考到的就是没有问题的菜
    22. 	 * 
    23. 	 * 
    24. 	 * 
    25. 	 * 因为m0()方法自己捕获了异常
    26. 	 * 所以m1()在调用m0()时不需要在处理异常了
    27. 	 */
    28. 	public static void m1() {
    29. 		m03();
    30. 	}
    31.  
    32. /**
    33. * 让用户控制台输入一个指定格式字符串
    34. * 然后将这个字符串解析为日期对象
    35. * 
    36. * 异常：菜炒糊了
    37. * 		：没放盐
    38. * 		：油多了
    39. * 捕获：厨师自己处理炒糊的菜（摘出来，重新炒）
    40. * @throws：ParseException
    41. * @throws：FileNotFoundException
    42. */
    43.  
    44.  
    45. public static void m0() {
    46. 	System.out.println("请输入日期（yyyy-MM-dd)");
    47.  
    48. 	String dateStr = new Scanner(System.in).nextLine();
    49. 	SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
    50. 	Date date;
    51. 	try {
    52. 		// 尝试去运行这块代码
    53. 		date = sdf.parse(dateStr);
    54. 		//try中代码出现异常，那么跟在后面的代码都不执行
    55. 		System.out.println("date=" + date);
    56. 		return;
    57. 	} catch (ParseException e) {
    58. 		// 只有Try中代码出现了异常
    59. 		// 才会catch中的代码
    60. 		System.out.println("==处理炒糊的菜==");
    61. 		//参数e代表捕获到的异常
    62. 		System.out.println("e："+e);
    63. 		//获取异常信息
    64. 		String  message =e.getMessage();
    65. 		System.out.println("message:"+message);
    66. 		
    67. 		//与jvm一样，打印输出异常的堆栈信息
    68. 		//e.printStackTrace();
    69. 		return;
    70. 	}finally {
    71. 		//最终执行代码块，无论try中代码有无异常
    72. 		//或try和catch中有无return，都会来执行的代码
    73. 		System.err.println("====最终执行代码块====");
    74. 	}
    75. }
    76. 	/**
    77. 	 * 让用户控制台输入一个指定格式字符串
    78. 	 * 然后将这个字符串解析为日期对象
    79. 	 * 
    80. 	 * 异常：菜炒糊了
    81. 	 * 		：没放盐
    82. 	 * 		：油多了
    83. 	 * 捕获：厨师自己处理炒糊的菜（摘出来，重新炒）
    84. 	 * @throws：ParseException
    85. 	 * @throws：FileNotFoundException
    86. 	 */
    87. 	
    88. 	
    89. 	public static void m01() {
    90. 		System.out.println("请输入日期（yyyy-MM-dd)");
    91. 		
    92. 		String dateStr = new Scanner(System.in).nextLine();
    93. 		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
    94. 		Date date;
    95. 		try {
    96. 			// 尝试去运行这块代码
    97. 			date = sdf.parse(dateStr);
    98. 			//从磁盘上读取数据，可能会发生读取异常
    99. 			FileInputStream in=new FileInputStream ("D:/a.text");
    100. 			in.read();
    101. 			//try中代码出现异常，那么跟在后面的代码都不执行
    102. 			System.out.println("date=" + date);
    103. 			
    104. 			return;
    105. 		} catch (ParseException e) {
    106. 			// 只有Try中代码出现了异常
    107. 			// 才会catch中的代码
    108. 			System.out.println("==日期解析异常==");
    109. 			//参数e代表捕获到的异常
    110. 			System.out.println("e："+e);
    111. 			//获取异常信息
    112. 			String  message =e.getMessage();
    113. 			System.out.println("message:"+message);
    114. 			
    115. 			//与jvm一样，打印输出异常的堆栈信息
    116. 			//e.printStackTrace();
    117. 			return;
    118. 		} catch (FileNotFoundException e) {
    119. 			//只有try中代码发生了文件未找到异常才能进入到这里执行
    120. 			//因为FileNotFoundException是IOException的子类型
    121. 			//要放在父类型的上面
    122. 			System.out.println("==文件未找到异常==");
    123. 		} catch (IOException e) {
    124. 			System.out.println("===文件读取异常====");
    125. 						e.printStackTrace();
    126. 		}finally {
    127. //			e.printStackTrace();
    128. 			//最终执行代码块，无论try中代码有无异常
    129. 			//或try和catch中有无return，都会来执行的代码
    130. 			System.err.println("====最终执行代码块====");
    131. 		}
    132. 	}
    133. 		
    134. 			
    135. 		/**
    136. 		 * 让用户控制台输入一个指定格式字符串
    137. 		 * 然后将这个字符串解析为日期对象
    138. 		 * 
    139. 		 * 异常：菜炒糊了
    140. 		 * 		：没放盐
    141. 		 * 		：油多了
    142. 		 * 捕获：厨师自己处理炒糊的菜（摘出来，重新炒）
    143. 		 * @throws：ParseException
    144. 		 * @throws：FileNotFoundException
    145. 		 */
    146. 		
    147. 		
    148. 		public static void m02() {
    149. 			System.out.println("请输入日期（yyyy-MM-dd)");
    150. 			
    151. 			String dateStr = new Scanner(System.in).nextLine();
    152. 			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
    153. 			Date date;
    154. 			try {
    155. 				// 尝试去运行这块代码
    156. 				date = sdf.parse(dateStr);
    157. 				//从磁盘上读取数据，可能会发生读取异常
    158. 				FileInputStream in=new FileInputStream ("D:/a.text");
    159. 				in.read();
    160. 				//try中代码出现异常，那么跟在后面的代码都不执行
    161. 				System.out.println("date=" + date);
    162. 				
    163. 				return;
    164. 			} catch (Exception e) {				
    165. 				System.out.println("==发生了异常，菜没炒好==");
    166. 				if(e instanceof ParseException) {
    167. 					System.out.println("日期");
    168. 				}else if(e instanceof FileNotFoundException) {
    169. 					System.out.println("文件没找到");
    170. 				}else if(e instanceof IOException) {
    171. 					System.out.println("读取异常");
    172. 				}else {
    173. 					System.out.println("其他异常");
    174. 				}
    175. 				return;
    176. 			} finally {
    177. //			e.printStackTrace();
    178. 				//最终执行代码块，无论try中代码有无异常
    179. 				//或try和catch中有无return，都会来执行的代码
    180. 				System.err.println("====最终执行代码块====");
    181. 			}
    182. 			
    183. 			
    184. 		
    185.  }
    186. 		
    187. 		/**
    188. 		 * 运行时候异常：通常不需要处理
    189. 		 * 如果想处理，也可以按照检查异常去处理
    190. 		 * 
    191. 		 * 如果有必要执行的代码
    192. 		 * try和finally可以单独使用
    193. 		 */
    194. 		public static void m03() {
    195. 			String arr[]= {"aa","bb","cc"};
    196. //			try {
    197. //				System.out.println(arr[5]);
    198. //		}catch(ArrayIndexOutOfBoundsException e) {
    199. //			System.out.println("数组下标越界异常");
    200. //		}
    201. 			
    202. 			try {
    203. 				System.out.println(arr[1]);
    204. 			}finally {
    205. 				System.out.println("123456789");
    206. 			}
    207. 		}
    208. }
    209.  
    210.  
    211.

     

  • 相关阅读:
    JavaScript项目1_猜数字（前导）
    岛屿问题（用DFS遍历二维数组）
    Linux 系统函数
    第四章 决策树
    C++PrimerPlus(第6版)中文版:Chapter16.5.1函数对象_函数符概念
    Win11不识别蓝牙适配器的解决方法
    一些文本在CSS上的作用
    八、2023.10.2.Linux（二）.8
    仿真软件Proteus8.9 SP2 Pro 下载、安装、汉化详细图文教程
    Kubernetes 部署 kubeflow1.6.1
  • 原文地址：https://blog.csdn.net/m0_72254454/article/details/126611326