兄弟连_马剑威_JAVA基础_088_自定义异常
[Android教程_兄弟连马剑威]_008_菜单
![[Android教程_兄弟连马剑威]_008_菜单](https://img.taocdn.com/s3/m/19e701dc84254b35eefd34f3.png)
第8讲：菜单课程•1、Optionsmenu andactionbar•2、Context menu•3、Popup menu大纲1、Options men选项菜单(i)•(Option Menu)•单击手机上的菜单键(MENU)出现nu and action bar1、Options men创建选项菜单的步骤•:•1、覆盖Activity 的onCreateOptionMenu(Menumenu)•2、调用Menu的add( )方法添加菜单项(MenuItem),同图标•3、当菜单项(MenuItem)被选择时,覆盖Activity 的onO•action barnu and action bar方法,当菜单第一次被打开时调用同时可以调用MenuItem 的setIcon( )方法来为菜单项设置OptionsItemSelected(MenuItem item)来响应事件2、Conte顾名思义有关思想类似于d•,与上下文(环境)有关。
思想类似于Windows某个东东不放。
•创建上下文菜单的步骤:覆盖menu•1、覆盖Activity的onCreateContextMenu(Menu•2、覆盖Activity 的onContextItemSelected(MenuItem i•3、调用registerForContextMenu( )方法来为视图注册上ext menu中的右键单击弹出的快捷菜单s 中的右键单击弹出的快捷菜单。
操作时需要长时间按住))方法,调用Menu 的add( 方法添加菜单项(MenuItem)。
item)来响应事件。
上下文菜单。
3、Popu弹出式菜单•.•弹出菜单是停靠在一个View上的一个模式菜单。
如果的下方，否则会显示在上方。
这是非常有用的。
•注意：弹出菜单是在API 级别11和更高版本上才有效up menu果View对象下方有空间，那么弹出菜单将显示在停靠对象效的。
自定义Java异常
自定义Java异常1.前言：你的程序总有一天会崩溃掉，在崩溃掉的时候我们要知道它在哪，为了什么而崩溃掉，数据的保存或者丢失情况如何等问题。
我们可以通过继承类ng.Throwable的子类：Exception来设计我们自己的Java异常。
Exception类用于描述程序能够捕获的异常，如ClassNotFoundException。
要注意的是自定义异常类之间也可以有继承关系，同时也需要为自定义异常类设计构造方法，以方便构造自定义异常对象。
2.设计实例分析：这是个比较完整的自定义异常类的设计，其实是比较模板化的东西。
package playground;import java.io.*;public class MyException extends Exception {private int id; // a unique idprivate String classname; // the name of the classprivate String method; // the name of the methodprivate String message; // a detailed messageprivate MyException previous =null; // the exception which was caughtprivate String separator = "\n"; // line separatorpublic MyException(int id, String classname, String method,String message, MyException previous) {this.id = id;this.classname = classname;this.method = method;this.message = message;this.previous = previous;}public String traceBack() {return traceBack("\n");}public String traceBack(String sep) {this.separator = sep;int level = 0;MyException e = this;String text = line("Calling sequence (top to bottom)");while (e != null) {level++;text += line("--level " + level +"--------------------------------------");text += line("Class/Method: " + e.classname + "/" + e.method);text += line("Id : " + e.id);text += line("Message : " + e.message);e = e.previous;}return text;}private String line(String s) {return s + separator;}}我们来一个个看看这些东西：在这个继承了Exception类的自定义异常类中，我们定义了如下变量：id：独立标示符，这个是用来进行标示类中什么地方出现了错误被捕捉到。
Java自定义异常与异常使用的最佳方式
Java⾃定义异常与异常使⽤的最佳⽅式⽬录异常的分类1. ⾮运⾏时异常(Checked Exception)2. 运⾏时异常（Runtime Exception/Unchecked Exception）异常的处理⼀、对应⾮运⾏时异常，必须对其进⾏处理⼆、对于运⾏时异常，可以不对其进⾏处理应⽤场景⾃定义异常类过程1. 多数情况下扩展2. 声明⽅法抛出⾃定义异常3.⾃定义异常测试操作使⽤异常的最佳实践1. 记得释放资源2. 不要使⽤异常作控制流程之⽤3. 不要忽略异常4. 不要 catch 最⾼层次的 exception5. 仅记录 exception ⼀次总结：异常的分类1. ⾮运⾏时异常(Checked Exception)Java中凡是继承⾃Exception但不是继承⾃RuntimeException的类都是⾮运⾏时异常。
2. 运⾏时异常（Runtime Exception/Unchecked Exception）RuntimeException类直接继承⾃Exception类，称为运⾏时异常。
Java中所有的运⾏时异常都直接或间接的继承⾃RuntimeException。
Java中所有的异常类都直接或间接的继承⾃Exception。
异常的处理⼀、对应⾮运⾏时异常，必须对其进⾏处理处理⽅式有两种：使⽤try…catch…finally语句块进⾏捕获在产⽣异常的⽅法所在的⽅法声明throws Exception⼆、对于运⾏时异常，可以不对其进⾏处理也可以对其进⾏处理。
⼀般情况下都不对其进⾏处理。
在使⽤Java API的⽅法时会产⽣异常，由于实际的需要，我们需要创建和使⽤⾃定义异常。
使⽤全新的异常类，应⽤到系统程序中。
在介绍⾃定义异常时，⾸要先谈谈什么要使⽤⾃定义异常，使⽤⾃定义异常的好处。
创建⾃定义异常是为了表⽰应⽤程序的⼀些错误类型，为代码可能发⽣的⼀个或多个问题提供新的含义；可以显⽰代码多个位置之间的错误的相似处，也可区分代码运⾏时可能出现的相似问题的⼀个或多个错误，或给出应⽤程序中⼀组错误的特殊含义。
[Java基础教程_兄弟连马剑威]_087_异常处理
![[Java基础教程_兄弟连马剑威]_087_异常处理](https://img.taocdn.com/s3/m/3668c7ef524de518964b7dc5.png)
2、 try与catch关键字
• • • • • • • • • • • 在程序中出现异常，就必须进行处理，处理格式如下： try{ // 有可能发生异常的代码段 }catch(异常类型 对象){ // 异常的处理操作 }catch(异常类型 对象){ // 异常的处理操作 } ... finally{ // 异常的统一出口 }
谢谢
nks
•
小结
• 异常处理的语法规则： 第一、try语句不能单独存在，可以和catch、finally组成 try...catch...finally、 try...catch、try...finally三种结构，catch语句可以有一个或多个，finally语句最多一个 ，try、catch、finally这三个关键字均不能单独使用。 第二、try、catch、finally三个代码块中变量的作用域分别独立而不能相互访问。 第三、多个catch块时候，Java虚拟机会匹配其中一个异常类或其子类，就执行这 个catch块，而不会再执行别的catch块。
异常处理
第 87 讲
马剑威
课程大纲
1、什么是异常 2、try与catch关键字 3、异常处理过程分析 4、finally关键字 5、throw与throws关键字
1、什么是异常
• 异常是阻止当前方法或作用域继续执行的问题，在程序中导致程序中断运行的一些 java中的异 指令。
常是怎样滴 涅？
1、什么是异常
3、异常处理过程分析
• • 1、一旦产生异常，则系统会自动产生一个异常类的实例化对象。 2、此时如果存在了try语句，则会自动找到匹配的catch语句执行，如果没有异常处理 ，则程序将退出，并由系统报告错误。 3、所有的catch根据方法的参数匹配异常类的实例化对象，如果匹配成功，则表示由 此catch进行处理。
Java异常处理的两种方式以及自定义异常的使用方法
Java异常处理的两种⽅式以及⾃定义异常的使⽤⽅法异常就是程序出现了不正常的情况Error：严重问题，不需要处理Exception：称为异常类，他表⽰程序本⾝可以处理的问题RuntimeException：在编译期是不检查的，出现问题后，需要我们回来修改代码⾮RuntimeException：编译期就必须处理的，否则程序不能通过编译，就更不能正常运⾏了JVM的默认处理⽅案如果程序出现了问题，我们没有做任何处理，最终JVM会做默认的处理把异常的名称，异常原因及异常出现的位置等信息输出在控制台程序停⽌执⾏异常处理两种⽅案：try...catch....throws.....try...catch...try{可能出现异常的代码；}catch(异常类名变量名){异常的处理代码；}执⾏流程：程序从try⾥⾯的代码开始执⾏出现异常，会⾃动⽣成⼀个异常类对象，该异常对象被提交给Java运⾏时的系统当Java运⾏时系统接收到异常对象时，回到catch中去找匹配的异常类，找到后进⾏异常的处理执⾏完毕后，程序还可以继续往下执⾏Throwable的成员⽅法：public class Demo1 {public static void main(String[] args) {System.out.println("开始");method();System.out.println("结束");}public static void method(){try {int[] arr = {1, 2, 3};System.out.println(arr[3]);}catch (ArrayIndexOutOfBoundsException e){System.out.println("你输⼊的索引有误");e.printStackTrace();System.out.println("---------");System.out.println(e.getMessage());System.out.println("--------------");System.out.println(e.toString());}}}编译时异常和运⾏时异常的区别Java中的异常被分为两⼤类：编译时异常和运⾏时异常，也被称为受检异常和⾮受检异常所有的RuntimeException类及其⼦类被称为运⾏时异常，其他的异常都是编译时异常编译时异常：必须显⽰处理，否则程序就会发⽣错误，⽆法通过编译运⾏时异常：⽆需显⽰处理，也可以和编译时异常⼀样处理throws通过try...catch...可以对异常进⾏处理，但是并不是所有的情况我们都有权限进⾏异常的处理，也就是说，有些时候可能出现的异常时我们处理不了的，怎么办？因此Java提供了throws的处理⽅案throws 异常类名;注：这个格式时跟在⽅法的括号后⾯的编译时异常必须要进⾏处理，两种处理⽅案：try...catch...或者throws，如果采⽤throws这种⽅案，将来谁调⽤谁处理运⾏时异常可以不处理，出现问题后，需要我们回来修改代码public class Demo2 {public static void main(String[] args) {try {method();} catch (ParseException e) {e.printStackTrace();}}public static void method() throws ParseException {String date = "2020-06-23";SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");Date parse = sdf.parse(date);System.out.println(parse);}}⾃定义异常Public class异常类名extends Exception{⽆参构造有参构造}throws和throw的区别throws：⽤在⽅法声明后⾯，跟的是异常类名表⽰抛出异常，由该⽅法的调⽤者来处理表⽰出现异常的⼀种可能性，并不⼀定会发⽣这些异常throw：⽤在⽅法体内，跟的是异常对象名表⽰抛出异常，由⽅法体内的语句处理执⾏throw⼀定抛出了某种异常1//⾃定义异常2public class ScoreException extends Exception{3public ScoreException(){}4public ScoreException(String message){5super(message);6 }7 }8//异常使⽤类9public class Teacher {10public void scoreTest(int score) throws ScoreException {11if(score < 0 || score>100){12throw new ScoreException("您输⼊的分数有误，请重新输⼊");13 }else{14 System.out.println("输⼊的分数正常");15 }16 }17 }18//异常测试类19public class ScoreExceptionTest {20public static void main(String[] args) {21 Scanner sc = new Scanner(System.in);22 System.out.println("请输⼊成绩：");23int score = sc.nextInt();24 Teacher teacher = new Teacher();25try {26 teacher.scoreTest(score);27 } catch (ScoreException e) {28 e.printStackTrace();29 }30 }31 }。
黑马程序员Java教程：自定义异常
自定义异常可以自定义出的问题称为自定义异常。
对于角标为负数的情况，可以用负数角标异常来表示，负数角标这种异常在java中并没有定义过。
那就按照java异常的创建思想，面向对象，将负数角标进行自定义描述，并封装成对象。
这种自定义的问题描述称为自定义异常。
P.S.如果让一个类成为异常类，必须要继承异常体系，因为只有成为异常体系的子类才有资格具备可抛性，才可以被两个关键字所操作：throws、throw。
自定义类继承Exception或者其子类，通过构造函数定义异常信息。
示例：1.Class DemoException extends Exception2.{3. DemoException(String message)4. {5. super(message);6. }7.}通过throw将自定义异常抛出。
throws和throw的区别：1. throws用于标识函数暴露出的异常类，并且可以抛出多个，用逗号分隔。
throw用于抛出异常对象。
2. thorws用在函数上，后面跟异常类名。
throw用在函数内，后面跟异常对象。
定义功能方法时，需要把出现的问题暴露出来让调用者去处理，那么就通过throws在函数上标识。
在功能方法内部出现某种情况，程序不能继续运行，需要进行跳转时，就用throw把异常对象抛出。
示例：1.class FuShuIndexException extends Exception{2. FuShuIndexException(){}3.4. FuShuIndexException(String msg){5. super(msg);6. }7.}8.9.class Demo{10.public static int method(int[] arr, int index) throwsFuShuIndexException{11. if(index < 0){12. throw new FuShuIndexException("数组的角标是负数啦！" );13. }14. return arr[index];15. }16.}17.18.class ExceptionDemo{19. public static void main(String[] args) throws FuShuIndexException{20. int[] arr = new int[3];21. Demo.method(arr,-30);22. }23.}运行结果：。
Java异常处理机制详解与自定义异常类创建
Java异常处理机制详解与自定义异常类创建异常是在程序运行过程中出现错误或意外情况的通知机制。
在Java中，异常可以分为受检异常（Checked Exception）和非受检异常（Unchecked Exception）。
受检异常需要在代码中显式处理，而非受检异常通常是由程序错误或其他不可控因素导致的，不需要显式处理。
Java异常处理机制详解受检异常（Checked Exception）受检异常是一种在编译时必须进行处理的异常。
它们是Exception类的子类，但不是RuntimeException类的子类。
在方法中抛出受检异常时，要么使用try-catch块捕获异常，要么在方法签名中使用throws子句声明可能抛出的异常。
非受检异常（Unchecked Exception）非受检异常是一种在运行时可能发生的异常。
它们是RuntimeException类及其子类的实例。
在方法中抛出非受检异常时，可以选择使用try-catch块捕获异常，但并非强制要求。
这种异常通常是由程序逻辑错误或其他不可控因素引起的。
异常处理关键字在Java中，异常处理使用try、catch和finally关键字。
try块包含可能发生异常的代码，catch块用于捕获处理异常，finally块中的代码始终会被执行，无论是否发生异常。
自定义异常类创建除了Java提供的异常类外，我们还可以自定义异常类。
自定义异常类通常继承自Exception类或其子类，以便区分不同类型的异常。
创建自定义异常类的步骤如下：1.创建异常类：定义一个类，通常继承自Exception类或RuntimeException类。
2.添加构造方法：定义一个构造方法，可以接受异常信息作为参数。
3.添加特定方法：为异常类添加自定义方法，以便在捕获异常时提供更多信息或处理逻辑。
示例：自定义异常类下面是一个简单的自定义异常类示例：public class CustomException extends Exception {public CustomException(String message) {super(message);}public void handleException() {// 添加异常处理逻辑}}在上面的示例中，CustomException是一个继承自Exception类的自定义异常类，它包含一个带有消息参数的构造方法和handleException方法用于处理异常。
Java异常处理与自定义异常共6页
Java异常处理与自定义异常Exception Handling and User-defined Exception in JAVA ProgrammingDA Lin-mei(Jiangsu Vocational and Technical College of Finance & Economics, Huai'an 223003, China)Abstract: The error occured during the Java program names exception. When it happens, there should be a corresponding exception handling mechanism to capture the exception or throw out it. JDK platform provides us with a rich and complete exception classes, through which we can deal with the error during the running of programs, in order to prevent the effect made by the error. Then the program can run safely. When these exception classes can not capture the exception in the practical application, it needs us to define the exception by ourselves. The same as exception handling ,the accurately and flexiblely using of user-defined exception will effectively enhance the interactiveness and the integrity of the program.众所周知,Java编程语言的特点之一是它的健壮性。
Java中自定义异常
Java中自定义异常Java 语言要求java 程序中（无论是谁写的代码），所有抛出（throw ）的异常都必须是从Throwable 派生而来。
当然，实际的Java 编程中，由于JDK 平台已经为我们设计好了非常丰富和完整的异常对象分类模型。
因此，java 程序员一般是不需要再重新定义自己的异常对象。
而且即便是需要扩展自定义的异常对象，也往往会从Exception 派生而来。
所以，对于java 程序员而言，它一般只需要在它的顶级函数中catch(Exception ex) 就可以捕获出所有的异常对象。
所有异常对象的根基类是Throwable ，Throwable 从Object直接继承而来（这是java 系统所强制要求的），并且它实现了Serializable 接口（这为所有的异常对象都能够轻松跨越Java 组件系统做好了最充分的物质准备）。
从Throwable 直接派生出的异常类有Exception 和Error 。
Exception 是java 程序员所最熟悉的，它一般代表了真正实际意义上的异常对象的根基类。
也即是说，Exception 和从它派生而来的所有异常都是应用程序能够catch 到的，并且可以进行异常错误恢复处理的异常类型。
而Error 则表示Java 系统中出现了一个非常严重的异常错误，并且这个错误可能是应用程序所不能恢复的，例如LinkageError ，或ThreadDeath 等。
首先还是看一个例子吧！代码如下：import java.io.*;public class Trans {public static void main(String[] args) {try {BufferedReader rd = null;Writer wr = null;try {File srcFile = new File((args[0]));File dstFile = new File((args[1]));rd = new BufferedReader(new InputStreamReader(new FileInputStream(srcFile), args[2]));Wr = new OutputStreamWriter(new FileOutputStream(dstFile),args[3]);// 注意下面这条语句，它有什么问题吗？if (rd == null || wr == null) {throw new Exception("error! test!");}while (true) {String sLine = rd.readLine();if (sLine == null)break;wr.write(sLine);wr.write("\r\n");}} finally {wr.flush();wr.close();rd.close();}} catch (IOException ex) {ex.printStackTrace();}}}熟悉java 语言的程序员朋友们，你们认为上面的程序有什么问题吗？编译能通过吗？如果不能，那么原因又是为何呢？好了，有了自己的分析和预期之后，不妨亲自动手编译一下上面的小程序，呵呵！结果确实如您所料？是的，的确是编译时报错了，错误信息如下：E:\Trans.java:20: unreported exception ng.Exception; must be caught or declared to be thrownif (rd == null || wr == null) throw new Exception("error! test!");1 error上面这种编译错误信息，相信Java 程序员肯定见过（可能还是屡见不鲜！）！相信老练一些的Java 程序员一定非常清楚上述编译出错的原因。
Java基础-异常（Exception）处理
Java基础-异常（Exception）处理 Java基础-异常（Exception）处理 作者：尹正杰版权声明：原创作品，谢绝转载！否则将追究法律责任。
⼀.异常的概述 什么是异常？Java代码在运⾏时期发⽣的问题就是异常。
在Java中，把异常信息封装成了⼀个类。
当出现了问题时，就会创建异常类对象，并抛出异常相关信息（如异常信息出现的位置，原因等）。
⼆.异常的继承体系 在Java中使⽤Exception类来描述异常。
Exception类及其⼦类是Throwable的⼀种形式，它指出了合理应⽤程序想要捕获的异常条件。
查看Java的API⽂档我们可以发现Exception有继承关系，它的⽗类是Throwable。
Throwable是Java语⾔中所有错误或异常的超类。
另外，在异常Exception类中，有⼀个⼦类要特殊说明⼀下，RuntimeException⼦类，RuntimeException及其它的⼦类只能在Java程序运⾏过程中出现。
我们再来观察Throwable类，能够发现与异常Exception平级的有⼀个Error，它是Throwable的⼦类，它⽤来表⽰Java程序中可能会产⽣的严重错误。
解决办法只有⼀个，修改代码避免Error错误的产⽣。
下⾯是⼀个Error异常的案例： 综上所述，异常继承体系可以⼤致做以下简要分类，此处并未列出全部的异常，请以Java的API⽂档为标准，下图只是为了⽅便记忆：三.异常对象的产⽣原因和处理⽅式 我们看见上⾯的代码是有异常抛出的，那么异常究竟是怎么抛出的呢？其实他⼤致分为以下⼏个步骤：1>.JVM检测到异常 通过上⾯的学习，我们知道异常的祖宗其实就是Throwable类，在这个类下⾯很多个⼦类已经提前定义好了。
在代码运⾏的时候，JVM是完全有能⼒检测到出现的异常信息（⽐如：ArrayIndexOutOfBoundsException）。
2>.JVM创建异常对象 当JVM虚拟机检测到异常后，⾸先会创建异常对象（⽐如：new ng.ArrayIndexOutOfBoundsException: 5）。
自定义异常推选文档
自自定定义 义异异常常类就中是往自往己不定写义p其的ub他异l方常ic法类c，，l只也as重就s载是异需AP要I常中使的类用标的准名构异造常e方类x法t的e直n接ds或E间x接c的ep子t类ion{ 如 在果方在法当 中前 通抛 过出thr异ow常关的键方字法抛中出处p自理u定b异义l常ic异，异常可以常使类用tr名y-ca(tcSht语r句in捕g获m并s处g理){，否则在方法的声明处通过throws关键字声明该异常 在作方用法 ：中用通自过定义thr异ow常关标键记字业抛务出逻自辑s定的u义异p异常e常r，(m避免sg与)标; 准异常混淆 } 自定义异常类中往往不写其他方法，只重载需要使用的构造方法
常混淆 如果在当前抛出异常的方法中处理异常，可以使用try-catch语句捕获并处理，否则在方法的声明处通过throws关键字声明该异常
作用：用自定义异常标记业务逻辑的异常，避免与标准异常混淆 super(msg); 自定义异常类中往往不写其他方法，只重载需要使用的构造方法 在程序中使用自定义异常大致可以分为以下几步 public 异常类名(String g){
示例
怎么使用自定义异常
在程序中使用自定义异常大致可以分为以下几步
– 创建自定义异常类 – 在方法中通过throw 关键字抛出自定义异常 – 如果在当前抛出异常的方法中处理异常，可以使用try-catch
语句捕获并处理，否则在方法的声明处通过throws关键字声 明该异常 – 调用throws声明该异常的方法时，使用try catch捕获自定义 的异常类型，并在catch中进行处理
自定义异常
自定义异常类 自定义异常类中往往不写其他方法，只重载需要使用的构造方法
自定义异常就是自己定义的异常类，也就是API中的标准异常类的直接或间接的子类 如果在当前抛出异常的方法中处理异常，可以使用try-catch语句捕获并处理，否则在方法的声明处通过throws关键字声明该异常
Java中自定义异常详解及实例代码
Java中⾃定义异常详解及实例代码Java中⾃定义异常详解及实例代码下⾯做了归纳总结,欢迎批评指正⾃定义异常class ChushulingException extends Exception{public ChushulingException(String msg){super(msg);}}class ChushufuException extends Exception{public ChushufuException(String msg){super(msg);}}⾃定义异常 Endclass Numbertest{public int shang(int x,int y) throws ChushulingException,ChushufuException{if(y<0){throw new ChushufuException("您输⼊的是"+y+",规定除数不能为负数!");//抛出异常}if(y==0){throw new ChushulingException("您输⼊的是"+y+",除数不能为0!");}int m=x/y;return m;}}class Rt001{public static void main(String[]args){Numbertest n=new Numbertest();//捕获异常try{System.out.println("商="+n.shang(1,-3));}catch(ChushulingException yc){System.out.println(yc.getMessage());yc.printStackTrace();}catch(ChushufuException yx){System.out.println(yx.getMessage());yx.printStackTrace();}catch(Exception y){System.out.println(y.getMessage());y.printStackTrace();}finally{ System.out.println("finally!");} ////finally不管发没发⽣异常都会被执⾏ }}/*[总结]1.⾃定义异常:class 异常类名 extends Exception{public 异常类名(String msg){super(msg);}}2.标识可能抛出的异常:throws 异常类名1,异常类名23.捕获异常:try{}catch(异常类名 y){}catch(异常类名 y){}4.⽅法解释getMessage() //输出异常的信息printStackTrace() //输出导致异常更为详细的信息感谢阅读，希望能帮助到⼤家，谢谢⼤家对本站的⽀持！。
java中如何自定义异常
java中如何⾃定义异常⾃定义异常：package com.javase.Exception;/*1 SUN提供的JDK内置的异常肯定是不够⽤的。
在实际开发中，有很多业务，这些业务出现异常之后，JDK中都是没有的，和业务挂钩，那么异常类我们程序员可以⾃⼰定义吗？可以的2 java中怎么⾃定义异常呢？两步：第⼀步：编写⼀个类继承Exception或者RuntimeException。
第⼆步：提供两个构造⽅法，⼀个⽆参数的，⼀个带有String参数的。
死记硬背。
*/public class ExceptionTest15 extends Exception{//编译时异常public ExceptionTest15(){}public ExceptionTest15(String message) {super(message);}}class MyException extends RuntimeException{// 运⾏时异常public MyException() {}public MyException(String message) {super(message);}}使⽤⾃定义异常：package com.javase.Exception;public class ExceptionTest16 {public static void main(String[] args) {// 创建异常对象(只是new了异常对象，并没有⼿动抛出。
)MyException e = new MyException("⽤户名不能为空");// 打印异常堆栈信息e.printStackTrace();// 获取异常简单描述信息String msg = e.getMessage();System.out.println(msg);}}。
Java异常之自定义异常
Java异常之⾃定义异常⾃定义异常类⾃定义异常1、使⽤ Java 内置的异常类可以描述在编程时出现的⼤部分异常情况。
除此之外，⽤户还可以⾃定义异常。
⽤户⾃定义异常类，只需继承 Exception 类即可。
2、在程序中使⽤⾃定义异常类，⼤体可以分为以下⼏个步骤：创建⾃定义异常类在⽅法中通过 throw 关键字抛出异常对象如果在当前抛出异常的⽅法中处理异常，可以使⽤ try-catch 语句捕获异常并处理；否则在⽅法的声明处通过 throws 关键字指明要抛出给⽅法调⽤者的异常，继续进⾏下⼀步操作在出现异常⽅法的调⽤者中捕获并处理异常3、实际应⽤中的经验总结：1. 处理运⾏时异常时，采⽤逻辑去合理规避同时辅助 try-catch 处理2. 在多重 catch 块后⾯，可以加⼀个 catch(Exception) 来处理可能会被遗漏的异常注：catch(Exception)是最⼤的异常类3. 对于不确定的代码，也可以加上 try-catch，处理潜在的异常4. 尽量去处理异常，切忌只是简单地调⽤ printStackTrace() 去打印输出5. 具体如何处理异常，要根据不同的业务需求和异常类型去决定6. 尽量添加 finally 语句块去释放占⽤的资源如：IO 流 ~ Scanner ~package exception.demo2;/*** java 异常之⾃定义异常：* 1、使⽤ Java 内置的异常类可以描述在编程时出现的⼤部分异常情况。
* 除此之外，⽤户还可以⾃定义异常。
⽤户⾃定义异常类，只需继承 Exception 类即可。
* 2、在程序中使⽤⾃定义异常类，⼤体可以分为以下⼏个步骤：* （1）创建⾃定义异常类* （2）在⽅法中通过 throw 关键字抛出异常对象* （3）如果在当前抛出异常的⽅法中处理异常，可以使⽤ try-catch 语句捕获异常并处理；* 否则在⽅法的声明处通过 throws 关键字指明要抛出给⽅法调⽤者的异常，继续进⾏下⼀步操作* （4）在出现异常⽅法的调⽤者中捕获并处理异常* 3、实际应⽤中的经验总结：* （1）处理运⾏时异常时，采⽤逻辑去合理规避同时辅助 try-catch 处理* （2）在多重 catch 块后⾯，可以加⼀个 catch(Exception) 来处理可能会被遗漏的异常* 注：catch(Exception)是最⼤的异常类* （3）对于不确定的代码，也可以加上 try-catch，处理潜在的异常* （4）尽量去处理异常，切忌只是简单地调⽤ printStackTrace() 去打印输出* （5）具体如何处理异常，要根据不同的业务需求和异常类型去决定* （6）尽量添加 finally 语句块去释放占⽤的资源如：IO 流 ~ Scanner ~*/public class MyException extends Exception {/*** 传递⼀个数字* 如果这个数字⼤于10 则抛出异常*/private int detail;//构造器public MyException(int a) {this.detail = a;}//toString：异常的打印信息@Overridepublic String toString() {return "捕获⾃定义异常 MyException { " +"当前参数 " + detail + " > 10 " +'}';}}测试类测试异常try-catch 语句捕获异常throw 关键字在⽅法中抛出异常throws 关键字在⽅法上抛出异常package exception.demo2;/*** 测试类* 测试异常*/public class Test {//可能会存在异常的⽅法static void test(int a) throws MyException {System.out.println("传递的参数为：" + a);if (a > 10) {/*** 此处可以通过 try-catch 语句捕获异常* 也可以在⽅法上通过 throws 关键字抛出异常 * 此处选择捕获，外⾯就不⽤再捕获* 此处选择抛出，外⾯需要捕获*/throw new MyException(a); //抛出}System.out.println("OK");}public static void main(String[] args) {//需要捕获异常try {test(11);} catch (MyException e) {//此处增加⼀些处理异常的代码块System.out.println("MyException => " + e); }}}。
Java异常（二）自定义异常
Java异常（⼆）⾃定义异常Java 异常（⼆）⾃定义异常在开发中，为了适应业务的开发需求，在 Java 中可以根据业务的异常情况⾃定义异常。
⼀、⾃定义异常所有的⾃定义异常都必须是 Throwable 的⼦类，在⾃定义继承时可以继承于 Exception 或者它的⼦类。
⼆、⾃定义异常的分类1、检查性异常类：⾃定义异常类继承于Exception。
2、运⾏时异常类：⾃定义异常类继承于RuntimeException三、Objects的⾮空判断Objects由⼀些静态的实⽤⽅法组成，这些⽅法是null-save（空指针安全的）或 null-tolerant（容忍空指针的），那么在它的源码中，对对象为null的值进⾏了抛出异常操作。
Objects通过调⽤requireNonNull（T obj）⽅法查看调⽤对象是否为null。
public static <T> T requireNonNull(T obj) { if (obj == null) throw new NullPointerException(); return obj;}从上⾯源码可以看出，如果传递对象为 null，requireNonNull ⽅法会抛出 NullPointerException 异常，否则返回该对象。
四、实例1、⾃定义检查性异常类（MyException）public class MyException extends Exception {public MyException() { } // ⽆参构造public MyException(String msg) {super(msg); // msg : 异常提⽰信息}public MyException(Throwable throwable) {super(throwable);// throwable 类型}}2、⾃定义运⾏时异常类（MyRuntimeException）public class MyRuntimeException extends RuntimeException {public MyRuntimeException() { } // ⽆参构造public MyRuntimeException(String msg) {super(msg); // msg : 异常提⽰信息}public MyRuntimeException(Throwable throwable) {super(throwable);// throwable 类型}}3、⾃定义异常的使⽤实例public class ExceptionDemo {public static void main(String[] args) throws Exception {int i = demo(3);System.out.println("i = " + i);}public static int demo(int index) throws MyException{int[] arr = {1,2,3};if(index >= arr.length || index < 0)throw new MyRuntimeException("您传递的索引错误，数组索引在0-2之间");return arr[index];}}4、Objects的⾮空判断实例public static void main(String[] args) throws Exception { Integer i = 10;Integer i2 = Objects.requireNonNull(i);System.out.println(i2);}。
Java异常处理：自定义异常
Java异常处理：⾃定义异常⼀、为什么要⾃定义异常类 1、为什么要⾃定义异常类 Java中不同的异常类,分别表⽰着某⼀种具体的异常情况,那么在开发中总是有些异常情况是没有定义好的,此时我们根据⾃⼰业务的异常情况来定义异常类。
⼀些异常都是 Java 内部定义好的，但是实际开发中也会出现很多异常,这些异常很可能在JDK中没有定义过,例如年龄负数问题,考试成绩负数问题，这时就需要我们⾃定义异常。
2、什么是⾃定义异常类 在开发中根据⾃⼰业务的异常情况来定义异常类。
⼆、异常类如何⾃定义 1、如何⾃定义 ①⼀般地，⽤户⾃定义异常类都是RuntimeException 的⼦类； ②⾃定义异常类通常需要编写⼏个重载的构造器； ③⾃定义异常需要提供 serialVersionID； ④⾃定义的异常通过 throw 抛出； ⑤⾃定义异常最重要的是异常类的名字，当异常出现时，可以根据名字判断异常类型； 2、案例 （1）⾃定义⼀个编译器异常：⾃定义类并继承 ng.Exception （2）⾃定义⼀个运⾏时期的异常类：⾃定义类，并继承于 ng.RuntimeException。
建议：保留两种构造器的形式 ①⽆参构造 ②带给⽗类的message属性赋值的构造器 语法格式：public class XXXExcepiton extends Exception | RuntimeException{添加⼀个空参数的构造⽅法添加⼀个带异常信息的构造⽅法} 注意： （1）⾃定义异常类⼀般都是以Exception结尾,说明该类是⼀个异常类 （2）⾃定义异常类,必须的继承Exception或者RuntimeException 继承Exception:那么⾃定义的异常类就是⼀个编译期异常,如果⽅法内部抛出了编译期异常,就必须处理这个异常,要么throws,要么try...catch 继承RuntimeException:那么⾃定义的异常类就是⼀个运⾏期异常,⽆需处理,交给虚拟机处理(中断处理) Demo：1public class DemoRegisterException {2// 1.使⽤数组保存已经注册过的⽤户名(数据库)3static String[] usernames = {"张三","李四","王五"};45public static void main(String[] args) /*throws RegisterException*/ {6//2.使⽤Scanner获取⽤户输⼊的注册的⽤户名(前端,页⾯)7 Scanner sc = new Scanner(System.in);8 System.out.println("请输⼊您要注册的⽤户名:");9 String username = sc.next();10 checkUsername(username);1112 }1314//3.定义⼀个⽅法,对⽤户输⼊的中注册的⽤户名进⾏判断15public static void checkUsername(String username) /*throws RegisterException*/ {16//遍历存储已经注册过⽤户名的数组,获取每⼀个⽤户名17for (String name : usernames) {18//使⽤获取到的⽤户名和⽤户输⼊的⽤户名⽐较19if(name.equals(username)){20//true:⽤户名已经存在,抛出RegisterException异常,告知⽤户"亲，该⽤户名已经被注册";21try {22throw new RegisterException("亲，该⽤户名已经被注册");23 } catch (RegisterException e) {24 e.printStackTrace();25return; //结束⽅法26 }27 }28 }2930//如果循环结束了,还没有找到重复的⽤户名,提⽰⽤户"恭喜您,注册成功!";31 System.out.println("恭喜您,注册成功!");32 }33 }3435// 异常类36public class RegisterException extends/*Exception*/ RuntimeException{37//添加⼀个空参数的构造⽅法38public RegisterException(){39super();40 }4142/*43添加⼀个带异常信息的构造⽅法44查看源码发现,所有的异常类都会有⼀个带异常信息的构造⽅法,⽅法内部会调⽤⽗类带异常信息的构造⽅法,让⽗类来处理这个异常信息45*/46public RegisterException(String message){47super(message);48 }49 }。
java异常介绍与自定义异常处理简述
java异常介绍与⾃定义异常处理简述
异常：
异常分两类：
1.Error是程序⽆法解决的错误，出现这类错误jvm会终⽌程序的运⾏。
具体的错误有：
1.1OutOfMenoryError是内存溢出错误
1.2StackOverflowError是栈内存溢出错误
2.Exception是异常是可以被处理的，它有运⾏时异常（RuntimeException）与⽂件操作异常(IOException)
2.1运⾏时异常都是RuntimeException类与其⼦类异常，⽐如ArithmerticException(算术异常)、NullPointException(空指针异常)、IndexOutOfBoundsException(下标越界)，
这类异常在编写过程中并不会被检查出来。
2.2⽂件操作异常IOException，这类异常必须进⾏显⽰处理（抛出或者捕获），常见的异常有。
EOFException读写异
常，FileNotFoundException⽂件未找到异常。
异常处理：
异常处理⽅式分为抛出异常与捕获异常。
⾃定义异常处理：
新建java类继承异常类。
1.1如果是处理系统异常就继承Excepption。
1.2如果是处理业务异常就继承RuntimeException。
测试：。
Java如何实现自定义异常类
Java如何实现⾃定义异常类这篇⽂章主要介绍了Java如何实现⾃定义异常类,⽂中通过⽰例代码介绍的⾮常详细，对⼤家的学习或者⼯作具有⼀定的参考学习价值,需要的朋友可以参考下⾃定义异常类步骤 创建⼀个类继承异常⽗类Exception 在具体的实现⽅法⾸部抛出异常类(⾃⼰创建的那个类)，throws的运⽤ 在具体的实现⽅法的内部抛出异常信息,throw的运⽤创建⼀个类继承异常⽗类Exceptionpublic class EmailException extends Exception {EmailException(String msg) {super(msg);}}在具体的实现⽅法⾸部抛出异常类(⾃⼰创建的那个类)，throws的运⽤在具体的实现⽅法的内部抛出异常信息,throw的运⽤import java.util.LinkedList;import java.util.List;public class UserRegiste {public List<String> usr;UserRegiste() {usr = new LinkedList<>();}public void regist(String email) throws EmailException {if (email.equals("123@")) {//抛出⾃定义的异常throw new EmailException("该⽤户已经存在了");} else {//如果不存在错误，则将信息添加进集合中usr.add(email);}}}import java.io.Console;import java.util.Scanner;public class one {public static void main(String amg[]) {UserRegiste userRegiste = new UserRegiste();Scanner scanner = new Scanner(System.in);System.out.println("邮箱:");String get = scanner.next();try {userRegiste.regist(get);} catch (EmailException e) {e.printStackTrace();}System.out.println("得到信息:");System.out.println(r.get(0));}}以上就是本⽂的全部内容，希望对⼤家的学习有所帮助，也希望⼤家多多⽀持。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
自定义异常
第88 讲
马剑威
1、自定义异常
自定义异常
1、自定义异常
•在Java中，已经提供了很多的异常类的定义，但是我们在实际项目开发中，可能需要使用些自己的异常类，那么可以通过继承Exception类或已有的异常类的方式完成使用一些自己的异常类，那么可以通过继承
一个自定义异常类的操作。
ClassNotFoundException
•ClassNotFoundException
•DataFormatException
•RuntimeException
ArithmeticException
•ArithmeticException
•IndexOutOfBoundsException
•NullPointerException
•ClassCastException
•……
自定义异常
1、自定义异常
•在Java中，已经提供了很多的异常类的定义，但是我们在实际项目开发中，可能需要使用些自己的异常类，那么可以通过继承Exception类或已有的异常类的方式完成使用一些自己的异常类，那么可以通过继承
一个自定义异常类的操作。
ClassNotFoundException
•ClassNotFoundException
•DataFormatException
•RuntimeException
ArithmeticException
•ArithmeticException
•IndexOutOfBoundsException
•NullPointerException
•ClassCastException
•……
作业
•1、模拟用户登录功能，从控制台输入用户名和密码，判断是否正确，如果输入不匹
配提示用户名或密码错误，如果输入匹配，显示用户登录成功等信息。
谢谢Th k Thanks。