当前位置: 首页 > news >正文

上海平台网站制作公司哪家好市场调研方法有哪些

上海平台网站制作公司哪家好,市场调研方法有哪些,化妆品做网站流程,金科网站建设1.Java的异常体系 Java 内置了丰富的异常体系, 用来表示不同情况下的异常. 下图表示 Java 内置的异常类之间的继承关系: 来看下图: 编译时异常意味着如果不处理这个异常的话,编译时就不能通过,直接飘红 运行时异常是运行的时候才发生的异常…

1.Java的异常体系

Java 内置了丰富的异常体系, 用来表示不同情况下的异常.

下图表示 Java 内置的异常类之间的继承关系:

来看下图:

编译时异常意味着如果不处理这个异常的话,编译时就不能通过,直接飘红

运行时异常是运行的时候才发生的异常

 2.异常的核心思想

异常的核心思想就是EAFP.

EAFP:It's Easier to Ask Forgiveness than Permission. "事后获取原谅比事前获取许可更容易". 也就是先操作, 遇到问题再处理.

所以说异常的核心思想其实就是程序先执行,出现异常了再去解决

我们来看一段EAFP风格的代码,稍后会对这段代码进行解释:

try {

登陆游戏();

开始匹配();

游戏确认();

选择英雄();

载入游戏画面();

...

} catch (登陆游戏异常) {

处理登陆游戏异常;

} catch (开始匹配异常) {

处理开始匹配异常;

} catch (游戏确认异常) {

处理游戏确认异常;

} catch (选择英雄异常) {

处理选择英雄异常;

} catch (载入游戏画面异常) {

处理载入游戏画面异常;

}

 3.异常的基本用法

3.1捕获异常

基本语法

try{

有可能出现异常的语句 ;

}[catch (异常类型 异常对象) {

} ... ]

[finally {

异常的出口

}]

1:try 代码块中放的是可能出现异常的代码.

2:catch 代码块中放的是出现异常后的处理行为.

3:catch括号总放入的是可能会出现的异常类型和异常对象

4:finally 代码块中的代码用于处理善后工作, 会在最后执行.

5:其中 catch finally 都可以根据情况选择加或者不加.

3.2代码示例

代码1 使用try catch来处理异常

1:假设此时我们不用try catch来处理异常

public class yichang {public static void main(String[] args) {int a = 0;System.out.println(10 / a);System.out.println("hh");}
}

运行后我们会发现此时最后一句输出语句根本不会被执行,原因是System.out.println(10/a)这条语句发生了算数异常,所以根本不会执行 System.out.println("hh"); 这条语句.

总结:假如不使用try catch处理异常的话,便会交给jvm处理异常,最终程序会异常终止,且不会继续执行发生异常之后的代码.

当使用try catch来处理异常后

public class yichang {public static void main(String[] args) {int a = 0;try {//try中存放的是可能会发生异常的代码System.out.println(10 / a);System.out.println("hhhh");} catch (ArithmeticException e) {//catch代码块放入的是处理异常的代码}System.out.println("hh");}
}//输出结果为hh

我们会发现当我们使用了try catch来处理了这个算术异常后,此时输出结果为hh.

同样System.out.println("hhhh")这句话不会执行,原因是在System.out.println(10/a)处发生了异常.

在来看一段代码:

public class yichang {public static void main(String[] args) {int[] arr = {1, 2, 3};try {System.out.println("before");System.out.println(arr[100]);System.out.println("after");} catch (ArrayIndexOutOfBoundsException e) {// 打印出现异常的调用栈e.printStackTrace();}System.out.println("after try catch");}
}//输出结果为beforejava.lang.ArrayIndexOutOfBoundsException: 100 at yichang.main(yichang.java:10)after try catch

 e.printStackTrace为打印出现异常的调用栈,所以就会出现输出结果中的第二行的话

代码2 catch 只能处理对应种类的异常

继续来看下面的代码,我们可以看到此时try中的代码会发生空指针异常,但是catch中捕获的却是数组越界异常,那么最终的System.out.println("after try catch");这条语句是不会被执行到的,原因是catch中所捕获的异常类型与实际发生的异常不匹配,所以处理异常失败。

public class yichang {public static void main(String[] args) {int[] arr = {1, 2, 3};try {System.out.println("before");arr = null;System.out.println(arr[100]);System.out.println("after");} catch (ArrayIndexOutOfBoundsException e) {/*e.printStackTrace();*/}System.out.println("after try catch");}
}

 最终输出结果为:

Exception in thread "main" java.lang.NullPointerException at yichang.main(yichang.java:11)

before

代码3 catch可以捕获多个异常

方法1:

public class yichang {public static void main(String[] args) {int[] arr = {1, 2, 3};//catch代码块可以捕获多个异常try {System.out.println("before");System.out.println(arr[100]);//因为此时上面的代码发生了异常,所以此时下面的代码是不会被执行的。System.out.println("after");} catch (ArithmeticException e) {e.printStackTrace();System.out.println("此段代码不会执行");} catch (ArrayIndexOutOfBoundsException e) {e.printStackTrace();System.out.println("捕获了数组越界异常");}System.out.println("after try catch");}
}//输出结果为before捕获了数组越界异常after try catchjava.lang.ArrayIndexOutOfBoundsException: 100 at yichang.main(yichang.java:11)

假如此时try中的代码发生的是数组下标越界异常,但是第一个catch中捕获的却是算术异常,那么这个catch中的代码是不会被执行的,第二个catch捕获的是数组下标越界异常,那么就会正常执行里面的代码,最后再执行System.out.println("after try catch");这条语句.

方法2:

除了可以像上述那样捕获多个异常以外,我们还可以通过|这个符号来捕获多个异常

如果多个异常的处理方式是完全相同, 也可以写成这样:

catch (ArrayIndexOutOfBoundsException | NullPointerException e) {

...

}

public class yichang {public static void main(String[] args) {int[] arr = {1, 2, 3};//catch代码块可以捕获多个异常try {System.out.println("before");System.out.println(arr[100]);//因为此时上面的代码发生了异常,所以此时下面的代码是不会被执行的。System.out.println("after");} catch (ArithmeticException | ArrayIndexOutOfBoundsException e) {System.out.println("此段代码不会执行");e.printStackTrace();}System.out.println("after try catch");}
}//输出结果为before此段代码不会执行java.lang.ArrayIndexOutOfBoundsException: 100 at yichang.main(yichang.java:11)after try catch

代码4 也可以用一个 catch 捕获所有异常(不推荐)

public class yichang {public static void main(String[] args) {int[] arr = {1, 2, 3};//也可以用一个 catch 捕获所有异常(不推荐)try {System.out.println("before");System.out.println(arr[100]);//因为此时上面的代码发生了异常,所以此时下面的代码是不会被执行的。System.out.println("after");//由于 Exception 类是所有异常类的父类. 因此可以用这个类型表示捕捉所有异常.} catch (Exception e) {e.printStackTrace();System.out.println("此段代码会执行");}}
}//输出结果
before
java.lang.ArrayIndexOutOfBoundsException: 100 at yichang.main(yichang.java:11)
此段代码会执行

由于 Exception 类是所有异常类的父类. 因此可以用这个类型表示捕捉所有异常.

代码5 finally

finally表示最后的善后工作, 例如释放资源.

scanner对象此时表示的是一种资源,资源最终要被释放

public class yichang {public static void main(String[] args) {//scanner中的close方法Scanner scanner = new Scanner(System.in);try {int a = scanner.nextInt();System.out.println(10 / a);} catch (ArithmeticException e) {e.printStackTrace();} finally {scanner.close();System.out.println("不管是否发生异常,finally块都会永远被执行");}}
}//输出结果
java.lang.ArithmeticException: / by zero at yichang.main(yichang.java:13)
不管是否发生异常,finally块都会永远被执行

注意:无论是否找到匹配的异常类型, finally 中的代码都会被执行到(在该方法结束之前执行). 来看如下代码

public class yichang {public static void main(String[] args) {int a=0;try {int ret=10/a;}catch (ArrayIndexOutOfBoundsException e){}finally {System.out.println("hhhh");}}
}

输出结果为:

hhhh
Exception in thread "main" java.lang.ArithmeticException: / by zero
    at yichang.main(yichang.java:9) 

可以看到,此时我们并没有在catch中找到匹配的异常类型,所以catch中的语句并不会执行,但是finally中的语句是无论是否找到匹配的异常类型, finally 中的代码都会被执行到,所以最终先输出hhh,再抛出算术异常.

代码6 使用try负责回收资源

刚才在代码5中,我们使用finally来回收资源,现在还有一种等价写法, Scanner 对象在 try ( ) 中创建, 就能保证在 try 执行完毕后自动调用 Scannerclose 方法.最终在finally中也不再需要去调用close方法.

public class yichang {public static void main(String[] args) {try(Scanner scanner = new Scanner(System.in)) {int a = scanner.nextInt();System.out.println(10 / a);} catch (ArithmeticException e) {e.printStackTrace();} finally {System.out.println("不管是否发生异常,finally块都会永远被执行");}}
}//输出结果
0
java.lang.ArithmeticException: / by zero at yichang.main(yichang.java:11)
不管是否发生异常,finally块都会永远被执行

代码7 建议finally中不要使用return语句

public class yichang {public static int func() {try {int a = 10;int ret = 10 / a;return ret;} catch (Exception e) {e.printStackTrace();} finally {return 10;}}public static void main(String[] args) {System.out.println(func());}
}//输出结果
10

原因是当我们调用func函数其实最想获得的是10/a的返回值,但是当我们在func函数中使用了finally之后,func函数的返回值变为了finally函数中return出来的值,不是我们想要的结果,所以最终输出结果不是3,而是10.所以我们并不建议在finally中使用return语句.

代码8 如果本方法中没有合适的处理异常的方式, 就会沿着调用栈向上传递

    在下面代码中,首先func方法并没有处理数组下标越界异常,所以此时会沿着栈向上传递到main方法,最终在main方法中找到了try catch来处理数组下标越界这个异常.

public class yichang {public static void func3() {int[] arr = {1, 2, 3};System.out.println(arr[100]);}public static void main(String[] args) {try {func3();} catch (ArrayIndexOutOfBoundsException e) {e.printStackTrace();}System.out.println("after try catch");}
}//输出结果
java.lang.ArrayIndexOutOfBoundsException: 100at yichang.func3(yichang.java:8)at yichang.main(yichang.java:13)
after try catch

代码示例9 如果向上一直传递都没有合适的方法处理异常, 最终就会交给 JVM 处理, 程序就会异常终止(和我们最开始未使用 try catch 时是一样的)

public class yichang {public static void func() {int[] arr = {1, 2, 3};System.out.println(arr[100]);}public static void main(String[] args) {func();System.out.println("hhh");}
}

输出结果为

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 100
    at yichang.func(yichang.java:8)
    at yichang.main(yichang.java:13)

可以看到, 程序已经异常终止了, 没有执行到 System.out.println("after try catch"); 这一行. 

总结

异常处理流程

1:程序先执行 try 中的代码.

2:如果 try 中的代码出现异常, 就会结束 try 中的代码, 看和 catch 中的异常类型是否匹配. 如果找到匹配的异常类型, 就会执行 catch 中的代码.

3:如果没有找到匹配的异常类型, 就会将异常向上传递到上层调用者.

4:无论是否找到匹配的异常类型, finally 中的代码都会被执行到(在该方法结束之前执行). 如果上层调用者也没有处理的了异常, 就继续向上传递.

5:一直到 main 方法也没有合适的代码处理异常, 就会交给 JVM 来进行处理, 此时程序就会异常终止.

3.3声明和抛出异常

声明异常:使用throws关键字

抛出异常:使用throw关键字

    一般声明异常和抛出异常都是搭配使用的,一个方法执行体中抛出了异常后,要在这个方法的后面声明抛出了哪些异常,这样是为了告诉方法的调用者这个方法声明了哪些异常,好让方法的调用者根据声明的不同异常来做出相应的处理操作,下面来看代码:

public class yichang {public static void func(int y) throws ArithmeticException,ArrayIndexOutOfBoundsException {if(y==0){throw new ArithmeticException();}System.out.println(10/y);}public static void main(String[] args) {try {func(0);} catch (ArithmeticException|ArrayIndexOutOfBoundsException e) {System.out.println("jj");} finally {System.out.println("hh");}}
}

3.4异常小练习

第1题(单选题)

题目名称

关于Java的异常处理机制的叙述哪些正确?

题目内容

A.如果程序发生错误及捕捉到异常情况了,才会执行finally部分

B.其他选项都不正确

C.当try区段的程序发生异常且被catch捕捉到时,才会执行catch区段的程序

D.catch部分捕捉到异常情况时,才会执行finally部分

正确答案:C

第2题(单选题)

题目名称

有关下述Java代码描述正确的选项是____。

public class TestClass {private static void testMethod() {System.out.println("testMethod");}public static void main(String[] args) {((TestClass)null).testMethod();}}

题目内容

A.编译不通过

B.编译通过,运行异常,报NullPointerException

C.编译通过,运行异常,报IllegalArgumentException

D.编译通过,运行异常,报NoSuchMethodException

E.编译通过,运行异常,报Exception

F.运行正常,输出testMethod

正确答案:F

解析:因为testMethod方法为静态方法,是不依赖于对象的,所以最终经过类型强转后是可以正常输出的.

第3题(单选题)

题目名称

下列程序的运行结果

public void getCustomerInfo() {try {// do something that may cause an Exception} catch (java.io.FileNotFoundException ex) {System.out.print("FileNotFoundException!");} catch (java.io.IOException ex) {System.out.print("IOException!");} catch (java.lang.Exception ex) {System.out.print("Exception!");}}

题目内容

A.IOException!

B.IOException!Exception!

C.FileNotFoundException!IOException!

D.FileNotFoundException!IOException!Exception!

正确答案:A

解析:从题中我们可以看到Exception这个异常是IOException这个异常的父类,而IOException是FileNotFoundException这个异常的父类,所以从整个代码来看的话,从上到下构成了子类到父类这样一个顺序,当try中假设抛出了FileNotFoundException这个异常的话,最终只会抛出对应 catch (java.io.FileNotFoundException ex)中的语句,并不会将catch (java.io.IOException ex)和 catch (java.lang.Exception ex)这两个catch中的语句抛出。

反例:假设此时我们变化catch的顺序,那么最终会发生什么呢?来看代码吧:

public void getCustomerInfo() {try {// do something that may cause an Exception} catch (java.lang.Exception ex) {System.out.print("Exception!");} catch (java.io.IOException ex) {System.out.print("IOException!");} catch (java.io.FileNotFoundException ex) {System.out.print("FileNotFoundException!");}}

当我们变化顺序后,当try中假设抛出了FileNotFoundException这个异常的话,最终只会抛出对应 catch (java.lang.Exception ex)中的语句,并不会将catch (java.io.IOException ex)和 catch (java.lang.FileNotFoundException ex)这两个catch中的语句抛出。

原因是Exception是FileNotFoundException的父类,父类已经捕捉到这个异常了,下面的catch语句当然不用再就继续捕捉了,且不管顺序如何,构成子父类关系的catch语句也只有一个会被执行

总结:以后捕捉异常的时候,从上往下,一定注意顺序,如果最上面是父类,那么下面的捕捉语句都不会被执行,所以应该先写子类的catch语句,再写父类的catch语句。

第5题(单选题)

题目名称

下面有关JAVA异常类的描述,说法错误的是?

题目内容

A. 异常的继承结构:基类为Throwable,Error和Exception继承Throwable,RuntimeException和IOException等继承Exception

B.非RuntimeException一般是外部错误(非Error),其必须被 try{}catch语句块所捕获

C. Error类体系描述了Java运行系统中的内部错误以及资源耗尽的情形,Error不需要捕捉

D.RuntimeException体系包括错误的类型转换、数组越界访问和试图访问空指针等等,必须被 try{}catch语句块所捕获

正确答案:D

解析:

A:正确

B:非RuntimeException包括了Error和编译时异常,然后又加上非Error后,就只剩下了编译时异常,编译时异常是必须被try catch捕获的

C:正确

D:运行时异常不一定非要被try catch捕获,不去捕获的话便会交给JVM去处理


4.自定义异常

注意事项

1:自定义异常通常会继承自 Exception 或者 RuntimeException.

2:继承自 Exception 的异常默认受查异常(编译时异常).

3:继承自 RuntimeException 的异常默认非受查异常(运行时异常).

代码实例 

代码1:手动定义异常原因

在手动抛出异常的时候,可以说明产生这个异常的原因,在异常后面的括号内写入原因即可

public class yichang {public static void main(String[] args) {try {throw new ArithmeticException("抛出算术异常");} catch (ArithmeticException e) {e.printStackTrace();}}
}

输出结果为:

java.lang.ArithmeticException: 抛出算术异常
    at yichang.main(yichang.java:14)

代码2:自己定义一个异常类

第一种情况:自己定义的这个异常类继承于RuntimeException

class MyException extends RuntimeException {public MyException(String message) {super(message);}
}public class yichang {public static void main(String[] args) {try {throw new MyException("抛出自己定义的异常");} catch (MyException e) {e.printStackTrace();}}
}

输出结果为:

MyException: 抛出自己定义的异常
    at yichang.main(yichang.java:16)

第二种情况:自己定义的这个异常类继承于Exception 

先来看两组代码:

class MyException extends RuntimeException {public MyException(String message) {super(message);}
}public class yichang {public static void main(String[] args) {int a=10;if(a==10){throw new MyException("sss");}}
}

 运行结果为:

Exception in thread "main" MyException: sss
    at yichang.main(yichang.java:15)

class MyException extends Exception {public MyException(String message) {super(message);}
}public class yichang {public static void main(String[] args) {int a=10;if(a==10){throw new MyException("sss");}}
}

运行结果报错:截图如下 

 可以看到,当我们自定义的异常类继承于RuntimeException,且在主方法中并没有使用try catch捕获我们自定义的异常的时候,最终会将异常交给我们的JVM处理,因为运行时异常既可以被try catch捕获,也可以交给JVM处理。

当我们自定义的异常类继承于Exception,且在主方法中并没有使用try catch捕获我们自定义的异常的时候,最终会报错,原因是继承于Exception的异常类属于编译时异常,也就是我们的受查异常,必须被try catch捕获。

同时我们还要注意:

假如在一个函数中所抛出(throw)的异常属于编译时异常,且这些编译时异常在这个函数中并没有使用try catch进行处理,那么首先需要在函数的后面声明(throws)异常,并且在主函数中调用这个函数的时候使用try catch来处理这些编译时异常.

假如在一个函数中所抛出的异常属于编译时异常,且这些编译时异常在这个函数中使用了try catch进行处理,那么就不需要在函数的后面声明异常,并且在主函数中调用这个函数的时候直接调用即可,也不需要拿try catch进行捕获异常和处理操作.

代码示例:

class MyException extends Exception {public MyException(String message) {super(message);}
}public class yichang {public static void print(int a) throws MyException {if (a == 0) {throw new MyException("编译时异常");}}public static void main(String[] args) {try {print(0);} catch (MyException e) {System.out.println("hh");}}
}

class MyException extends Exception {public MyException(String message) {super(message);}
}public class yichang {public static void print(int a) {try {if (a == 0) {throw new MyException("编译时异常");}} catch (MyException e) {System.out.println("hh");}}public static void main(String[] args) {print(0);}
}
http://www.wooajung.com/news/26462.html

相关文章:

  • 建站用哪个模板好seo关键词快速提升软件官网
  • 专门做外贸的的网站有哪些seo网站排名优化教程
  • 建立个人博客网站b2b网站大全
  • 新建网站需要多少钱百度关键词推广公司
  • 正邦设计电话seo搜外
  • 网站建设服务合同模板下载品牌推广内容
  • 网站后台里有网页代码没网络营销的主要推广方式
  • 做网站最好的语言搜索引擎广告
  • 岳阳网站开发服务爱站网络挖掘词
  • 河南省城乡建设信息网谈谈你对seo概念的理解
  • 支付宝手机网站支付seo优化资源
  • 最新疫情消息全国厦门seo蜘蛛屯
  • 景观设计案例网站百度提交入口网站网址
  • 苗木 网站模板有没有免费推广平台
  • 公司英文网站建设2022年网络流行语
  • 网站开发优势宁波seo搜索引擎优化
  • com网站是用什么做的今日军事新闻报道
  • 聊城菜鸟网站建设公司网站优化内容
  • 济南网站制作案例百家号权重查询站长工具
  • facebook怎么推广网站优化算法
  • 0735郴州新网招聘seo排名赚挂机赚钱软件下载
  • 永嘉规划建设局网站南平seo
  • 北京上海网站建设公司北京seo优化费用
  • 网站建设制作流程一键免费生成网页的网站
  • 独立网站建设的步骤做推广哪个平台效果好
  • 用手机域名做网站搜索排行榜
  • 网站建设分几种类型无经验能做sem专员
  • 在招聘网站里做电话销售百度上海分公司
  • 东莞 网站制作百度竞价关键词优化
  • 网站域名主机空间区别重庆百度快速优化