黑马程序员技术交流社区
标题:
【记录】代码练习-异常处理
[打印本页]
作者:
Kevin.Kang
时间:
2015-7-21 16:18
标题:
【记录】代码练习-异常处理
程序异常：Throwable
严重问题：Error不作处理，这种问题一般都是很严重的，比如内存溢出
问题：Exception
编译期：不是RuntimeException的异常，必须进行处理，不处理，编译不能通过
运行期：RuntimeException，这种问题不处理，这种问题的出现肯定是代码不够严谨导致，需要修正代码。
程序如果出现问题，而我们没有做任何处理，最终JVM会做出默认的处理。
把异常名称，原因和出现的问题等信息输出在控制台。同时结束程序，后面的不再执行。
作者:
Kevin.Kang
时间:
2015-7-21 16:20
本帖最后由 Kevin.Kang 于 2015-7-22 12:59 编辑
package com.kxg.exception;
/*
* 自己处理异常：
* try...catch..finally
* throws 抛出
*
* try...catch...finally格式：
* 格式1：
* try{
* 可能出现问题的代码;
* }catch(异常名 变量){
* 问题的处理;
* }finally{
* 释放资源;
* }
* 格式2：
* try{
* 可能出现问题的代码;
* }catch(异常名 变量){
* 问题的处理;
* }
* 格式3：
* try{
* 可能出现问题的代码;
* }catch(异常名 变量){
* 问题的处理;
* }catch(异常名 变量){
* 问题的处理;
* }
* 格式4：JDK7的新异常处理方案
* try{
* 可能出现问题的代码;
* }catch(异常名1|异常名2|...变量){
* 问题的处理;
* }
* 缺点：
* 处理方法是一致的
* 多个异常必须是平级关系
*
* 注意：
* try里面的代码越少越好。
* catch里面必须有内容。
* 处理多个异常：
* 能够明确异常名的尽量明确，不要用捕获大范围的异常
* 实在不明确的异常可以使用大范围的，必须放到最后位置，平级关系无所谓。
*
*
*/
public class ExceptionDemo {
public static void main(String[] args) {
int i = 10;
int j = 0;
int[] arr = new int[3];
try {
System.out.println(i / j);
System.out.println(arr[3]);
} catch (ArrayIndexOutOfBoundsException ai) {
System.out.println("超出范围");
} catch (Exception e) {
System.out.println("0不能作除数");
}
System.out.println("好好学习，天天向上");
}
}
复制代码
try里面有多个异常代码，只能查找第一个，如果产生了异常，try里面就会自动生成一个异常对象，然后把这个对象抛出，
一旦某个catch捕获到匹配的异常类型，将进入异常处理代码。一经处理结束，就意味着整个try-catch语句结束。其他的catch子句不再有匹配和捕获异常类型的机会。
作者:
Kevin.Kang
时间:
2015-7-21 17:58
本帖最后由 Kevin.Kang 于 2015-7-21 18:04 编辑
编译时异常和运行时异常的区别：
编译期异常：java程序必须显示处理，否则程序就会发生错误，无法通过编译。
运行期异常：无需显示处理，也可以和编译时异常一样处理。
编译期异常：
package com.kxg.exception;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class ExceptionDemo2 {
public static void main(String[] args) {
String s = "164646464";
date2(s);// 方法自己处理了，可以继续往下执行
// date(s);//继续抛给main函数，主函数会接着抛给虚拟机，虚拟机做出处理，程序结束。
// 调用者自己做出处理，程序会继续往下执行。
try {
date(s);
} catch (ParseException e) {
e.printStackTrace();
}
System.out.println("程序结束");
}
// 处理1： 抛出异常，代表这个方法会出现异常，需要调用者进行处理，不然编译不通过。
public static void date(String s) throws ParseException {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
Date d = sdf.parse(s);
System.out.println(d);
}
// 处理2： 方法处理异常
public static void date2(String s) {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
Date d = null;
try {
d = sdf.parse(s);
} catch (ParseException e) {
System.out.println("解析错误");
}
System.out.println(d);
}
}
复制代码
作者:
vinoMVP
时间:
2015-7-21 18:03
学习了。。。。
作者:
Kevin.Kang
时间:
2015-7-21 18:16
运行期异常：
package csdn.test;
public class Test {
public static void main(String[] args) {
// 方法抛出异常，调用者进行处理
try {
method();
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("===================");
// 不用处理，方法做过处理
method2();
System.out.println("===================");
// 方法内部throw抛出异常，方法外部接着抛出，调用者可以处理，也可以继续抛给主方法，不过程序会结束。
try {
method3();
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("===================");
// 然并卵？
method4();
}
// 方法出于某种原因不处理，抛给调用者进行处理。
public static void method() throws Exception {
int a = 1;
int b = 0;
System.out.println(a / b);
}
// 方法自己进行处理，不再抛出
public static void method2() {
int a = 1;
int b = 0;
try
{
System.out.println(a / b);
} catch (Exception e)
{
System.out.println("出错");
}
}
// throw抛出1
public static void method3() throws Exception {
int a = 1;
int b = 0;
if (b == 0) {
throw new Exception();
} else {
System.out.println(a / b);
}
}
// throw抛出2
public static void method4() {
int a = 1;
int b = 0;
if (b == 0) {
throw new ArithmeticException();
} else {
System.out.println(a / b);
}
}
}
复制代码
作者:
小灬清新丶
时间:
2015-7-21 18:49
呵呵，广少好努力啊
作者:
Kevin.Kang
时间:
2015-7-22 11:30
throws和throw区别：
throws:
用在方法声明后面，跟的是异常名
可以跟多个异常名，用都好隔开
表示抛出异常，由该方法的调用者处理
throws表示出现异常的一种可能性，并不一定会发生这些异常
throw：
用在方法体内，跟的是异常对象名。
只能抛出一个具体异常对象名
表示抛出异常，由方法体内的语句处理
throw表示抛出了异常，执行throw一定抛出了某种异常。
作者:
Kevin.Kang
时间:
2015-7-22 15:18
package com.kxg.exception;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
/*
* finally:被finally控制的语句体一定会执行
*
* 格式
* try...catch...finally
* 作用：
* 用于释放资源，在IO流操作和数据库操作中会见到
*/
public class FinallyDemo {
public static void main(String[] args) {
String s = "1992-02-27";
SimpleDateFormat sdf = new SimpleDateFormat("yyy-MM-dd MM:hh:ss");
try {
Date d = sdf.parse(s);
} catch (ParseException e) {
e.printStackTrace();
} finally {
System.out.println("finally控制语句");
}
}
}
复制代码
作者:
Kevin.Kang
时间:
2015-7-22 15:26
final,finally,finalize的区别：
final：最终的意思。修饰成员变量，成员方法，类
修饰成员变量：变量是常量
修饰成员方法：不能被重写
修饰类：不能被继承
finally：异常处理的一部分，用于释放资源。
finalize：Object类中的一个方法，用于垃圾回收。
同样用于垃圾回收的还有System类下的gc()方法。
作者:
Kevin.Kang
时间:
2015-7-22 17:29
try...catch...finally的格式变形：
try...catch...finally
try...catch
try...catch...catch
try...catch...catch...finally
try...finally(这种做法是为了释放资源)
作者:
Kevin.Kang
时间:
2015-7-23 11:16
自定义异常：
package com.kxg.exception2;
public class MyException extends Exception {
public MyException() {
}
public MyException(String s) {
super(s);
}
}
复制代码
package com.kxg.exception2;
public class Person {
public void check(int i) throws MyException {
if (i > 100 || i < 0) {
throw new MyException("数据有误");
} else {
System.out.println("数据无误");
}
}
}
复制代码
package com.kxg.exception2;
import java.util.Scanner;
public class NumberDemo {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入数字(1-100)：");
int i = sc.nextInt();
Person p = new Person();
try {
p.check(i);
} catch (MyException e) {
e.printStackTrace();
}
}
}
复制代码
作者:
Kevin.Kang
时间:
2015-7-23 11:25
继承中异常注意事项：
1.子类重写父类方法时，子类的方法必须抛出和父类相同的异常，或父类异常的子类。
2.如果父类方法抛出多个异常，子类重写父类方法事，只能抛出相同的异常或者是他的子类。子类不能抛出父类没有的异常。
3.如果被重写的方法没有异常抛出，那么子类的方法绝对不可以抛出异常，如果子类方法中有异常产生，那么子类只能try，不能throws。
欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/)
黑马程序员IT技术论坛 X3.2