lanza palabra clave
La palabra clave throws se usa principalmente en la definición del método, lo que indica que este método no maneja excepciones, sino que se entrega a la parte llamada para su procesamiento.
Ejemplo: usar tiros
package com.study.Demo;
class MyMath{
public static int div(int x,int y)throws Exception{ //此方法不处理异常
return x/y;
}
}
public class Test4 {
public static void main(String args[]){
try{ //div()方法抛出异常，必须明确进行异常处理
System.out.println(MyMath.div(10,5));
}catch (Exception e){
e.printStackTrace();
}
}
}
//结果
//2
Consejo: Los lanzamientos también se pueden usar en el método principal.
Ejemplo: usar tiros en el método principal
package com.study.Demo;
class MyMath{
public static int div(int x,int y)throws Exception{ //此方法不处理异常
return x/y;
}
}
public class Test4 {
public static void main(String args[]) throws Exception{
//表示此异常产生后会直接通过主方法抛出，代码中可以不强制使用异常处理
System.out.println(MyMath.div(10,0));
}
}
//结果
//Exception in thread "main" java.lang.ArithmeticException: / by zero
// at com.study.Demo.MyMath.div(Test4.java:5)
// at com.study.Demo.Test4.main(Test4.java:10)
lanzar palabra clave
La palabra clave throw puede lanzar manualmente un objeto instanciado por el usuario.
Ejemplo: lanzar manualmente una excepción
package com.study.Demo;
public class Test4 {
public static void main(String args[]){
try{
throw new Exception("自己定义的异常");
}catch (Exception e){
e.printStackTrace();
}
}
}
//结果
//java.lang.Exception: 自己定义的异常
// at com.study.Demo.Test4.main(Test4.java:11)
Formato estándar para manejo de excepciones
Ejemplo:
package com.study.Demo;
class MyMath{
public static int div(int x,int y)throws Exception{ //出现异常要交给被调用处输出
System.out.println("计算开始");
int result=0;
try{
result=x/y;
}catch (Exception e){
throw e; //向上抛
}finally {
System.out.println("计算结束");
}
return result;
}
}
public class Test3 {
public static void main(String args[]){
try {
System.out.println(MyMath.div(10,0)); //被调用处处理异常
}catch (Exception e){
e.printStackTrace();
}
}
}
RuntimeException 类
Las características de la clase RuntimeException: el
programa no obligará al usuario a manejar la excepción en el momento de la compilación. El usuario puede manejarla selectivamente de acuerdo a sus propias necesidades, pero si ocurre una excepción sin procesamiento, la JVM lo manejará por defecto.
Ejemplo:
package com.study.Demo;
public class Test4 {
public static void main(String args[]){
int temp=Integer.parseInt("100");
System.out.println(temp);
}
}
//结果
//100
Este código se ejecuta normalmente, pero si ocurre una excepción, se entrega a la JVM para el procesamiento predeterminado.
afirmar palabra clave
La función principal de la palabra clave afirmar es hacer afirmaciones. La aserción se refiere a la ejecución de un programa en una línea determinada, el resultado debe ser el resultado esperado.
Ejemplo: observar el uso de aserciones
package com.study.Demo;
public class Test5 {
public static void main(String args[]){
int num=10;
//假设中间可能经过了20行代码来操作num的内容，期望的内容应该是20
assert num==20:"num的内容不是20"; //进行断言操作
System.out.println("num="+num);
}
}
//结果
//num=10
El resultado no es una excepción, esto se debe a que Java no habilita la aserción de forma predeterminada. Si desea habilitar las aserciones, debe hacer lo siguiente:
1. Abra el panel de control correspondiente
2. Ingrese -ea
Excepción personalizada
Clases de excepción desarrolladas por los usuarios.
Si desea implementar una clase de excepción personalizada, solo necesita heredar la clase primaria Exception o RuntimeException.
Ejemplo: definir AddException
package com.study.Demo;
class AddException extends Exception{ //此异常类要强制处理
public AddException(String msg){
super(msg); //调用父类构造
}
}
public class Test5 {
public static void main(String args[]){
int num=20;
try{
if(num>10){ //出现了错误，应该产生异常
throw new AddException("数值传递的过大");
}
}catch (Exception e){
e.printStackTrace();
}
}
}
//结果
//com.study.Demo.AddException: 数值传递的过大
// at com.study.Demo.Test5.main(Test5.java:13)
