千锋逆战班day27
作者：互联网
day27
千锋逆战学习第27天
坚持就是胜利
6、自定义异常
继承Exception（受查异常）或Exception的子类。常用RunTimeException（运行时异常）
必要提供的内容
无参构造方法
String message参数的构造方法。定义异常原因信息
package com.qf.day27.defined;
public class TestDefinedException {
public static void main(String[] args) {
Student stu=new Student();
try {
stu.setAge(250);
} catch (Exception e) {
System.out.println(e.getMessage());//只获得报错的原因即可
}
try {
stu.setSex("未知");
} catch (SexMismatchException se) {//根据方法声明的异常，捕捉相应的
System.err.println(se.getMessage());
}catch (Exception e) {
e.printStackTrace();
}
}
}
//受查异常（在编译期间，就必须处理的异常！需要声明出去）
class SexMismatchException extends Exception{
public SexMismatchException() {}
public SexMismatchException(String message) {
super(message);
}
}
//运行时异常
class AgeInputException extends RuntimeException{
public AgeInputException(){}//支持创建无异常原因信息的异常对象
public AgeInputException(String message){//提供有参构造方法，支持编写异常原因信息
super(message);//调用父类的有参构造方法，为message赋值
}
}
//在应用场景下，可以根据自身的需要，自定义异常
class Student{
private int age;
private String sex;
public String getSex() {
return sex;
}
public void setSex(String sex)throws SexMismatchException {//告知调用者,使用该方法会产生异常，必须处理。声明的异常最好与抛出的异常一致
if(sex.equals("男")||sex.equals("女")){
this.sex=sex;
}else{
//在用户输入一个性别后：做好提醒，性别的输入可能不准确！受查异常
throw new SexMismatchException("性别输入应该为“男”或“女”");
}
}
public int getAge() {
return age;
}
public void setAge(int age) {
if(age>0&&age<123){
this.age=age;
}else{
throw new AgeInputException("年龄的赋值应该在0-123岁之间");//
}
}
}
7、异常方法覆盖
方法名、参数列表、返回值类型必须和父类相同
子类的访问修饰符合父类相同或是比父类更宽
子类中的方法，不能抛出比父类更宽泛的异常
package com.qf.day27.override;
import java.io.IOException;
import java.sql.SQLException;
public class TestOverrideExceptionMethod {
public static void main(String[] args) {
Super sup=new Sub();//父类引用指向子类对象 多态
try {
sup.method();//在编译期间，调用的父类中声明的方法是有异常的，需要处理
} catch (Exception e) {
e.printStackTrace();
}
}
}
//带有异常的方法覆盖
//1、父类中方法声明了异常。子类重写后可声明也可不声明
//2、父类中方法没有声明异常，则子类也不可以声明异常
//3、父类中方法声明了异常，子类可以声明的异常与其相当或其子类
//4、子类可以声明比父类更多的异常，必须小于其父类声明的异常
class Super{
public void method() throws Exception{
System.out.println("method in super");
}
}
class Sub extends Super{
public void method() throws ClassNotFoundException,RuntimeException,IOException,SQLException {
System.out.println("method in sub");
}
}
interface Printable{
public void print() throws Exception;
}
class MyClass implements Printable{
public void print() throws ClassNotFoundException,RuntimeException {
}
}
Chapter 11 异常
Key Point：
●异常的概念和分类
●异常的产生和传递
●异常的处理
●自定义异常
习题：
1、填空
java中所有的错误都继承自 Throwable 类；在该类的子类中， Error 类表示严重的底层错误，对于这类错误一般的处理方式是 不应该试图捕捉他 ； Exception 类表示例外、异常
2、查询API，填空
异常类java.rmi.AlreadyBoundException类；从分类上说，该类属于 已检查 异常，从处理方式上说，对这种异常 必须 处理
异常类java.util.regex.PattemSynataxException,从分类上说，该类属于 运行时 异常，从处理方式上说，对这种异常 可处理可不处理 处理
3、（异常的产生）把下面代码补全
public class TestThrow {
public static void main(String[] args) {
throwException(10);
}
public static void throwException(int n){
if(n==0){
//抛出一个NullPointerException
throw new NullPointerException();
}else{
//抛出一个ClassCastException
//并设定详细信息为“类型转换出错”
throw new ClassCastException(“类型转换出错”);
}
}
}
4、（try-catch-finally）有以下代码：
import java.io.;
import java.sql.;
public class TestException {
public static void main(String[] args) {
System.out.println(“main 1”);
int n;
//读入n
ma(n);
System.out.println(“main 2”);
}
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(n1)throw new EOFException();
if(n2)throw new FileNotFoundException();
if(n3)throw new SQLException();
if(n4)throw new NullPointerException();
System.out.println(“mb2”);
}
}
问：当读入的n分别为1，2，3，4，5时，输出的结果分别是什么？
答：n=1时：
main 1
ma1
mb1
Catch EOFException
In finally
main 2
n=2时：
main 1
ma1
mb1
Catch IOException
In finally
main 2
n=3时：
main 1
ma1
mb1
Catch SQLException
In finally
main 2
n=4时：
main 1
ma1
mb1
Catch Exception
In finally
main 2
n=5时：
main 1
ma1
mb1
mb2
ma2
In finally
main 2
5、（自定义异常）创建两个自定义异常类MyException1和MyException2
要求：
MyException1为已检查异常，MyException2为运行时异常
这两个异常均具有两个构造函数，一个无参，另一个带字符串参数，参数表示产生异常信息
class MyException1 extends Exception{
public MyException1(){}
public MyException1(String message){
super(message);
}
}
class MyException2 extends RuntimeException{
public MyException2(){}
public MyException2(String message){
super(message);
}
}
6、（自定义异常）在上一题的基础上，把下面代码补充完整
public class TestMyException {
public static void main(String[] args) {
int n=1;
//读入n
try {
m(n);
} catch (MyException1 ex1) {
//输出ex1详细的方法调用栈信息
System.out.println(ex1.getMessage());
ex1.printStackTrace();
}catch (MyException2 ex2) {
// 输出ex2的详细信息
//并把ex2重新抛出
System.out.println(ex2.getMessage());
throw ex2;
}
}
public static void m(int n) throws MyException1{//声明抛出MyException1
if(n1){
//抛出MyException1
//并设定其详细信息为“n1”
throw new MyException1("n1");
}else{
//抛出MyException2
//并设定其详细信息为“n2”
throw new MyException2(“n==2”);
}
}
}
7、(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();
}
}
改完为：
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");
}
return 200;
}
public static void m() throws Exception{
throw new Exception();
}
}
8、（方法覆盖）有以下代码：
import java.io.IOException;
class Super{
public void ma()throws IOException{}
}
interface IA{
void mb();
}
public class MySub extends Super implements IA{
public void ma()/1/{}
public void mb()/2/{}
}
问：在//1处，填入以下哪行代码可以编译通过，AB
在//2处填入以下哪行代码可以编译通过 D
A.throws java.io.IOException{}
B.throwsjava.io.FileNotFoundException,java.io.EOFException
C.throws java.sql.SQLException
D.不能抛出任何异常
9、（try-catch 局部变量）有以下代码：
public class TestTryCatch {
public static void main(String[] args) {
System.out.println(ma());
}
public static int ma(){
int n;
try{
n=10/0;
}catch (Exception e) {
}
return n;
}
}
选择正确答案： A
A.编译不通过
B.编译通过，输出-1
C.编译通过，输出0
10、（try-catch-finally)有以下代码：
public class TestFinally {
public static void main(String[] args) {
System.out.println(ma());
}
public static int ma(){
int b;
//读入b
try {
int n=100;
return n/b;
} catch (Exception e) {
return 10;
}finally{
return 100;
}
}
}
在ma中，当读入的b为100时，输出的结果为 100 ,当读入的b为0时，输出结果为 100
11、（try-finally）写出下面代码的运行结果
public class TestTryFinally {
public static void main(String[] args) {
try {
ma();
} catch (Exception e) {
}
}
public static void ma() throws Exception{
int n=10;
int b;
//读入一个整数b
try{
System.out.println(“ma1”);
int result=n/b;
System.out.println(“ma2”+result);
}finally{
System.out.println(“In Finally”);
}
}
}
在ma中，读入整数b。如果读入的值为10，则输出：
ma1
ma21
In Finally
如果读入的值为0，则输出：
ma1
In Finally
12、（方法覆盖）
class MySuper{
public void m() throws IOException{}
}
class MySub extends MySuper{
public void m() throws EOFException{}
}
class MySub2 extends MySub{
public void m() throws FileNotFoundException{}
}
以上代码是否能 编译通过？如果不能，应该如何修改？
答：不能
class MySub2 extends MySuper{
public void m() throws FileNotFoundException{}
}
13、（异常的捕捉和抛出）有以下代码：
public class TestException {
public static void main(String[] args) {
try{
System.out.println(“main1”);
ma();
System.out.println(“main2”);
}catch (Exception e) {
System.out.println(“In Catch”);
}
}
public static void ma(){
System.out.println(“ma1”);
throw new NullPointerException();
System.out.println(“ma2”);
}
}
选择正确答案： A
A.编译出错
B.编译正常，输出main1 ma1 In Catch
C.编译正常，运行时出错
14、（异常的捕捉和抛出）有以下代码：
import java.io.;
import java.sql.;
class TestException {
public static void main(String[] args) {
try{
ma();
}
//1
catch (Exception e) {
}
}
public static void ma() throws IOException{}
}
下列哪些代码放在//1处可以编译通过 AB
A.catch(NullPointerException npe){}
B.catch(IOException ioe){}
C.catch(SQLException sqle){}
标签：千锋,day27,System,public,逆战班,class,println,void,out 来源： https://blog.csdn.net/Y_L_Lee/article/details/104771144