异常处理的消极方式，不断给方法抛出异常：
package com.pyc.test;
import java.io.IOException;
import java.sql.SQLException;
public class TestMain {
public static void main(String [] args)throws SQLException,IOException {
ma();
}
public static void ma()throws SQLException,IOException
{
System.out.println("开始ma");
mb();
System.out.println("结束ma");
}
public static void mb()throws SQLException,IOException{
System.out.println("开始mb");
mc();
System.out.println("结束mb");
}
public static void mc()throws SQLException,IOException{
System.out.println("开始mc");
md("2");
System.out.println("结束mc");
}
public static void md(String i)throws SQLException,IOException{
System.out.println("开始md");
if(i.equals("1")) {
throw new NullPointerException();
}else if(i.equals("2")) {
throw new SQLException();
}else if(i.equals("3")) {
throw new IOException();
}
//throw new NullPointerException();
}
}
异常的处理积极方式，使用try catch语句：
package com.pyc.test;
import java.io.IOException;
import java.sql.SQLException;
public class TestMain {
public static void main(String [] args) {
ma();
}
public static void ma()
{
System.out.println("开始ma");
mb();
System.out.println("结束ma");
}
public static void mb(){
System.out.println("开始mb");
mc();
System.out.println("结束mb");
}
public static void mc(){
System.out.println("开始mc");
try{
md("2"); //这里通过改变数值测试是有错误还是没错误
//System.err.println("这时抛出的异常");//测试走不走这一步，结果不走
}catch(SQLException e) {
e.printStackTrace();//注释掉它之后，不通知用户错没错
//System.err.println("这时抛出的异常");
}catch(IOException e) {
e.printStackTrace();
}finally { //是否产生异常都会运行，是必须运行的，只能和try catch连起来用
System.err.println("这时抛出的异常");
}
System.out.println("结束mc");
}
public static void md(String i)throws SQLException,IOException{
System.out.println("开始md");
if(i.equals("1")) {
throw new NullPointerException();
}else if(i.equals("2")) {
throw new SQLException();
}else if(i.equals("3")) {
throw new IOException();
}
//throw new NullPointerException();
}
}
注：Exception是所有异常类的一个父类，抛异常的时候如果放在最上面，下面的异常catch就失去作用，显示错误，因此父类异常应该放在最下面。
异常类的重写：
class Super {
public void sup() throws SQLException,IOException{//所有编译异常的父类：RuntimeException
}
}
class Supers extends Super{
public void sup() throws SQLException{ //子类里重写方法所抛出的异常不能大于父类里抛出的异常，子类中可以不抛
throw new SQLException();
}
}
/*class Supers extends Super{
public void sup() throws IOException{
//throw new SQLException();
}
}*/
class MyException extends Exception{
public MyException(String str) {
super(str);
}
}
class MyRuntimeException extends RuntimeException{
public MyRuntimeException(String str) {
super(str);
}
//public MyRuntimeException(String str) {
//super(str);
//}
}
异常父类重写的全部代码：
package com.dhy.test;
import java.io.IOException;
import java.sql.SQLException;
import java.text.SimpleDateFormat;
public class TestMain {
public static void main(String[] args) {
//运行时异常
// int s=0;
// System.out.println(10/s);
//编译期异常
// SimpleDateFormat sdf=new SimpleDateFormat("yyyy");
// sdf.parse("2018");
ma();
// Super su=new Supers();
// su.sup();
}
public static void ma() {
System.err.println("开始ma");
mb();
System.err.println("结束ma");
}
public static void mb() {
System.err.println("开始mb");
System.err.println(mc());
System.err.println("结束mb");
}
public static int mc() {
System.err.println("开始mc");
try {
System.err.println(md("5"));
} catch (Exception e) {
e.printStackTrace();
}
// catch (SQLException e) {
//// e.printStackTrace();
// } catch (IOException e) {
// e.printStackTrace();
// }
finally {
System.err.println("这是在抛出的异常");
}
System.err.println("结束mc");
return 1;
}
public static int md(String i) throws SQLException,IOException,MyException{
System.err.println("开始md");
if(i.equals("1")) {
throw new NullPointerException();
}else if(i.equals("2")) {
throw new SQLException();
}else if(i.equals("3")) {
throw new IOException();
}else if(i.equals("4")) {
throw new MyException("这是一个自己定义的错误");
}else if(i.equals("5")) {
throw new MyRuntimeException("这是一个自己定义的运行时错误");
}
return 2;
}
}
//class Super{
// public void sup ()throws RuntimeException {
//
// }
//}
//class Supers extends Super{
// public void sup(){
//// throw new SQLException();
// }
//}
class MyException extends Exception{
public MyException(String str) {
super(str);
}
}
class MyRuntimeException extends RuntimeException{
public MyRuntimeException(String str) {
super(str);
}
public MyRuntimeException() {
}
}
8月2日作业：
1.（try-catch-finally）有如下代码：
import java.io.*;
import java.sql.*;
class TestException{
public static void main(String args[]){
System.out.println(“main 1”);
int n;
//读入 n
ma(n);
System.out.println(“main2”);
}
public static void ma(int n){
try{
System.out.println(“ma1”);
mb(n);
System.out.println(“ma2”);
}catch(EOFException e){
System.out.println(“Catch EOFException”);
}catch(IOException e){
System.out.println(“Catch IOException”);
}catch(SQLException e){
System.out.println(“Catch SQLException”);
}catch(Exception e){
System.out.println(“Catch Exception”);
}finally{
System.out.println(“In finally”);
}
}
public static void mb(int n) throws Exception{
System.out.println(“mb1”);
if (n == 1) throw new EOFException();
if (n == 2) throw new FileNotFoundException();
if (n == 3) throw new SQLException();
if (n == 4) throw new NullPointerException();
System.out.println(“mb2”);
}
}
问：当读入的 n 分别为 1，2，3，4，5 时，输出的结果分别是什么？
2.）创建两个自定义异常类 MyException1 和 MyException2。
要求：
1) MyException1 为已检查异常，MyException2 为未检查异常
2) 这两个异常均具有两个构造函数，一个无参，另一个带字符串参数，参数表示产生
异常的详细信息。
3.(try-catch）代码改错。
class MyException{}
class TestException{
public static void main(String args[]){
ma();
}
public static int ma(){
try{
m();
return 100;
}catch(Exception e){
System.out.println(“Exception”);
}
catch(ArithmeticException e){
System.out.println(“ArithmeticException”);
}
}
public static void m(){
throw new MyException();
}
}
4.（异常的捕获和抛出）有以下代码：
import java.io.*;
import java.sql.*;
public class TestMyException{
public static void main(String args[]){
try{
System.out.println("main1");
ma();
System.out.println("main2");
}catch(Exception e){
System.out.println("Catch Exception in main");
System.out.println(e.getMessage());
}
}
public static void ma() throws IOException{
try{
System.out.println("ma1");
mb();
System.out.println("ma2");
}catch(SQLException e){
System.out.println("Catch SQLException in ma");
throw new IOException(e.getMessage());
}catch(Exception e){
System.out.println("Catch Exception in ma");
System.out.println(e.getMessage());
}
}
public static void mb() throws SQLException{
throw new SQLException("sql exception in mb");
}
}
问：该程序输出结果是什么？
1.问：当读入的 n 分别为 1，2，3，4，5 时，输出的结果分别是什么？
答：当n=1时，输出结果是main 1 ma1 mb1 Catch EOFException In finally main2
当n=2时，main 1 ma1 mb1 Catch IOException In finally main2
当n=3时，main 1 ma1 mb1 Catch SQLExceptionIn finally main2
当n=4时，main 1 ma1 mb1 Catch Exception In finally main2
当n=5时，main 1 ma1 mb1 mb2 ma2 In finally main2
2.创建两个自定义异常类 MyException1 和 MyException2。
要求：
- MyException1 为已检查异常，MyException2 为未检查异常
2) 这两个异常均具有两个构造函数，一个无参，另一个带字符串参数，参数表示产生
异常的详细信息。
public class MyException1 extends Exception(){
public MyException1 (){
}
public MyException1 (String str){
super(str);
}
}
public class MyException2 extends RunTimeException(){
public MyException2 (){
}
public MyException2 (String str){
super(str);
}
}
3.(try-catch）代码改错。
class MyException{}
class TestException{
public static void main(String args[]){
ma();
}
public static int ma(){
try{
m();
return 100;
}catch(ArithmeticException e){
System.out.println(“ArithmeticException”);
}catch(Exception e){
System.out.println(“Exception”);
}
}
public static void m(){
throw new MyException();
}
}
- 该程序的输出结果是：
main1
ma1
Catch SQLException in ma
Catch Exception in main
sql exception in mb