60_Java_异常

举报
alexsully 发表于 2021/06/03 00:20:47 2021/06/03
1.8k+ 0 0
【摘要】 异常 try catch finally throws throw 自定义异常

 异常体系结构 

java.lang.Throwable 顶级父类
    |-----java.lang.Error:一般不编写针对性的代码进行处理。
    |-----java.lang.Exception:可以进行异常的处理
       |------编译时异常(checked) 收检异常
            |-----IOException
                  |-----FileNotFoundException
            |-----ClassNotFoundException
       |------运行时异常(unchecked,RuntimeException) 非收检异常
            |-----NullPointerException
            |-----ArrayIndexOutOfBoundsException
            |-----ClassCastException
            |-----NumberFormatException
            |-----InputMismatchException
            |-----ArithmeticException  算术异常
// ArithmeticException
    @Test
    public void test6(){
        int a = 10;
        int b = 0;
        System.out.println(a / b);
    }

// InputMismatchException
    @Test
    public void test5(){
      Scanner scanner = new Scanner(System.in);
      int score = scanner.nextInt();
      System.out.println(score);
      scanner.close();
    }
    
// NumberFormatException
  @Test
  public void test4(){
    String str = "123";
      str = "abc";
      int num = Integer.parseInt(str);
    }
    
// ClassCastException
    @Test
    public void test3(){
        Object obj = new Date();
        String str = (String)obj;
    }
    
// IndexOutOfBoundsException
    @Test
    public void test2(){
// ArrayIndexOutOfBoundsException
        int[] arr = new int[10];
        System.out.println(arr[10]);
//  StringIndexOutOfBoundsException
        String str = "abc";
        System.out.println(str.charAt(3));
    }
    
//  NullPointerException
    @Test
    public void test1(){
     String str = "abc";
     str = null;
     System.out.println(str.charAt(0));
    }
}
异常的处理:抓抛模型  每个异常都被定义成类;

过程一:"抛":程序在正常执行的过程中,一旦出现异常,就会在异常代码处生成一个对应异常类的对象。
        并将此对象抛出。一旦抛出对象以后,其后的代码就不再执行
        关于异常对象的产生:1 系统自动生成的异常对象; 2手动的生成一个异常对象,并抛出(throw)

过程二:"抓":可以理解为异常的处理方式:1 try-catch-finally  2 throws*


二、try-catch-finally的使用
try{
    可能出现异常的代码
 } catch(异常类型1 变量名1){
     处理异常的方式1
 }catch(异常类型2 变量名2){
    处理异常的方式2
 }catch(异常类型3 变量名3){
    处理异常的方式3
 }

finally{
    一定会执行的代码
}

说明:
1. finally是可选的。
2. 使用try将可能出现异常代码包装起来,在执行过程中,一旦出现异常,就会生成一个对应异常类的对象,根据此对象
   的类型,去catch中进行匹配
3. 一旦try中的异常对象匹配到某一个catch时,就进入catch中进行异常的处理。一旦处理完成,就跳出当前的
   try-catch结构(在没有写finally的情况)。继续执行其后的代码
4. catch中的异常类型如果没有子父类关系,则谁声明在上,谁声明在下无所谓。
   catch中的异常类型如果满足子父类关系,则要求子类一定声明在父类的上面。否则,报错
5. 常用的异常对象处理的方式: 1 String  getMessage()    2 printStackTrace()
6.try结构中声明的变量,再出了try结构以后,就不能再被调用
7. try-catch-finally结构可以嵌套

  public void test2(){
        try{
            File file = new File("hello.txt");
            FileInputStream fis = new FileInputStream(file);
            
            int data = fis.read();
            while(data != -1){
                System.out.print((char)data);
                data = fis.read();
            }

            fis.close();
        }catch(FileNotFoundException e){
            e.printStackTrace();
        }catch(IOException e){
            e.printStackTrace();
        }
    }
 
Java 处理异常的方式: 1 try-catch- finally ; 2 throws+ 异常类型

1  try-catch-finally中finally的使用:
   1. finally是可选的
   2. finally中声明的是一定会被执行的代码。即使catch中又出现异常了,try中有return语句,catch中有 return语句等情况。
   3. 像数据库连接、输入输出流、网络编程Socket等资源,JVM是不能自动的回收的,我们需要自己手动的进行资源的释放。此时的资源释放,就需要声明在finally中。
 
 
方法重写的规则之一: 子类重写的方法抛出的异常类型不大于父类被重写的方法抛出的异常类型


public class OverrideTest {
	
	public static void main(String[] args) {
		OverrideTest test = new OverrideTest();
		test.display(new SubClass());
	}
	public void display(SuperClass s){
		try {
			s.method();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

class SuperClass{
	
	public void method() throws IOException{
		
	}
}

class SubClass extends SuperClass{
	public void method()throws FileNotFoundException{
		
	}
}

方式二:throws + 异常类型
1. "throws + 异常类型"写在方法的声明处。指明此方法执行时,可能会抛出的异常类型。
    一旦当方法体执行时,出现异常,仍会在异常代码处生成一个异常类的对象,此对象满足throws后异常类型时,就会被抛出。异常代码后续的代码,就不再执行!
    
2. 体会:try-catch-finally:真正的将异常给处理掉了。
   throws的方式只是将异常抛给了方法的调用者。  并没有真正将异常处理掉。  

3. 开发中如何选择使用try-catch-finally 还是使用throws?
  3.1 如果父类中被重写的方法没有throws方式处理异常,则子类重写的方法也不能使用throws,意味着如果
      子类重写的方法中有异常,必须使用try-catch-finally方式处理。
  3.2 执行的方法a中,先后又调用了另外的几个方法,这几个方法是递进关系执行的。我们建议这几个方法使用throws
      的方式进行处理。而执行的方法a可以考虑使用try-catch-finally方式进行处理。

 
 
如何自定义异常类
 1. 继承于现有的异常结构:RuntimeException 、Exception
 2. 提供全局常量:serialVersionUID
 3. 提供重载的构造器
 
public class EcmDef {
    public static void main(String[] args) {
        try{
            int i = Integer.parseInt(args[0]);
            int j = Integer.parseInt(args[1]);

            int result = ecm(i,j);

            System.out.println(result);
        }catch(NumberFormatException e){
            System.out.println("数据类型不一致");
        }catch(ArrayIndexOutOfBoundsException e){
            System.out.println("缺少命令行参数");
        }catch(ArithmeticException e){
            System.out.println("除0");
        }catch(EcDef e){
            System.out.println(e.getMessage());
        }

    }

    public static int ecm(int i,int j) throws EcDef{   // 抛出异常处理方式
        if(i < 0 || j < 0){
            throw new EcDef("分子或分母为负数了!");  // 制造异常
        }
        return i / j;
    }
}

class EcDef extends Exception {   // 自定义异常

    static final long serialVersionUID = -33875164229948L;

    public EcDef() {
    }

    public EcDef(String msg) {
        super(msg);
    }
}

【声明】本内容来自华为云开发者社区博主,不代表华为云及华为云开发者社区的观点和立场。转载时必须标注文章的来源(华为云社区)、文章链接、文章作者等基本信息,否则作者和本社区有权追究责任。如果您发现本社区中有涉嫌抄袭的内容,欢迎发送邮件进行举报,并提供相关证据,一经查实,本社区将立刻删除涉嫌侵权内容,举报邮箱: cloudbbs@huaweicloud.com
  • 点赞
  • 收藏
  • 关注作者

作者其他文章

评论(0

抱歉,系统识别当前为高风险访问,暂不支持该操作

    全部回复

    上滑加载中

    设置昵称

    在此一键设置昵称,即可参与社区互动!

    *长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。

    *长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。