Java 求大神们解答：自定义异常,处理异常

Posted 2023-05-15

### 操作步骤
1.自定义异常类MyException，继承Exception,要有无参和有一个字符串参数的构造方法
2.定义一个普通类UsingMyException，里面定义两个无参方法-f()和g()，f()方法要使用throws和throw抛出MyException类，并输出一句话--"抛出异常MyException 从 f()方法",g()方法要使用throws和throw抛出MyException类，并输出一句话--"抛出异常MyException 从 g()方法",并调用MyException类的有参构造方法，传入“从g()方法中抛出异常”,
3.定义测试类:在测试类中调用两次try--catch,调用一次finally关键字。
### 控制台输出如下内容:
抛出异常MyException 从 f()方法
抛出异常MyException 从 g()方法
从g()方法中抛出异常
最终结束
### 请编写程序，实现上述要求。

以下是一个符合您要求的Java程序示例：
javaCopy codeclass MyException extends Exception public MyException() super();
public MyException(String message) super(message);

class UsingMyException public void f() throws MyException
System.out.println("抛出异常MyException 从 f()方法"); throw new MyException();
public void g() throws MyException
System.out.println("抛出异常MyException 从 g()方法"); throw new MyException("从g()方法中抛出异常");

public class TestException public static void main(String[] args) UsingMyException obj = new UsingMyException(); try
obj.f();
catch (MyException e)
System.out.println(e.getMessage());
try
obj.g();
catch (MyException e)
System.out.println(e.getMessage());
finally
System.out.println("最终结束");




在这个程序中，我们首先定义了一个MyException类，它继承自Exception类，并具有无参和一个字符串参数的构造函数。接下来，我们定义了一个普通类UsingMyException，并在其中定义了两个方法f()和g()，这两个方法都抛出MyException异常并输出相应的信息。最后，我们编写了一个测试类TestException，在其中调用了UsingMyException类的f()和g()方法，并使用try-catch语句捕获了抛出的异常，并输出相应的信息。我们还使用了finally关键字来确保在程序结束时执行某些特定的代码。
当您运行这个程序时，它将在控制台上输出符合您要求的内容。 参考技术A // 自定义异常类MyException
class MyException extends Exception
// 无参构造方法
public MyException()
// 有一个字符串参数的构造方法
public MyException(String message)
super(message);


// 普通类UsingMyException
class UsingMyException
// 抛出MyException异常的f()方法
public void f() throws MyException
System.out.println("抛出异常MyException 从 f()方法");
throw new MyException();

// 抛出MyException异常的g()方法
public void g() throws MyException
System.out.println("抛出异常MyException 从 g()方法");
throw new MyException("从g()方法中抛出异常");


public class Main
public static void main(String[] args)
UsingMyException usingMyException = new UsingMyException();
try
usingMyException.f();
catch (MyException e)
e.printStackTrace();

try
usingMyException.g();
catch (MyException e)
System.out.println(e.getMessage());
finally
System.out.println("最终结束");



控制台输出:
抛出异常MyException 从 f()方法
抛出异常MyException 从 g()方法
从g()方法中抛出异常
最终结束 参考技术B

// 自定义异常类 MyException

class MyException extends Exception

public MyException()

super();

public MyException(String message)

super(message);

// 普通类 UsingMyException

class UsingMyException

public void f() throws MyException

System.out.println("抛出异常 MyException 从 f() 方法");

throw new MyException();

public void g() throws MyException

System.out.println("抛出异常 MyException 从 g() 方法");

throw new MyException("从 g() 方法中抛出异常");

// 测试类

public class TestMyException

public static void main(String[] args)

UsingMyException obj = new UsingMyException();

try

obj.f();

catch (MyException e)

e.printStackTrace();

try

obj.g();

catch (MyException e)

System.out.println(e.getMessage());

finally

System.out.println("最终结束");

运行程序后，输出如下内容：

抛出异常 MyException 从 f() 方法
MyException
at UsingMyException.f(TestMyException.java:10)
at TestMyException.main(TestMyException.java:21)
抛出异常 MyException 从 g() 方法
从 g() 方法中抛出异常
最终结束

解释一下输出结果：

第一次调用 obj.f() 方法时，会抛出 MyException 异常，并输出 "抛出异常 MyException 从 f() 方法"。异常被 catch 语句捕获，然后调用 printStackTrace() 方法打印异常信息。

第二次调用 obj.g() 方法时，会抛出 MyException 异常，并输出 "抛出异常 MyException 从 g() 方法"。异常被 catch 语句捕获，然后调用 getMessage() 方法获取异常信息，并输出 "从 g() 方法中抛出异常"。

最后输出 "最终结束"。由于 finally 关键字的作用，无论是否发生异常，该语句块都会执行。

参考技术C Java 允许我们定义自己的异常，这样的异常就称为自定义异常。定义自定义异常的方式是继承 Exception 类，然后定义一个类来代表该异常。
下面是定义自定义异常类的示例：
================
public class MyException extends Exception
public MyException()
super();

public MyException(String message)
super(message);


================
这里定义了一个名为 MyException 的类，它继承了 Exception 类，并定义了两个构造方法，一个是无参构造方法，另一个是带有一个字符串参数的构造方法，该字符串参数用于传入错误信息。
接下来，我们可以在可能抛出异常的方法中使用 throws 关键字声明该方法可能抛出的异常，并在方法中使用 throw 语句抛出异常。例如：
================

public class UsingMyException
public void f() throws MyException
System.out.println("抛出异常MyException 从 f()方法");
throw new MyException();

public void g() throws MyException
System.out.println("抛出异常MyException 从 g()方法");
throw new MyException("从g()方法中抛出异常");


================
这里我们定义了一个名为 UsingMyException 的类，它包含两个方法： f() 和 g()。两个方法都使用了 throws 关键字声明它们可能会抛出 MyException 异常，并在方法内部使用 throw 语句抛出该异常 参考技术D 以下是实现MyException异常类、UsingMyException普通类以及测试类的代码：
// MyException.java
public class MyException extends Exception
public MyException()
public MyException(String message)
super(message);


// UsingMyException.java
public class UsingMyException
public void f() throws MyException
System.out.println("抛出异常MyException 从 f()方法");
throw new MyException();


public void g() throws MyException
System.out.println("抛出异常MyException 从 g()方法");
throw new MyException("从g()方法中抛出异常");


// Test.java
public class Test
public static void main(String[] args)
UsingMyException um = new UsingMyException();
try
um.f();
catch (MyException e)
e.printStackTrace();


try
um.g();
catch (MyException e)
e.printStackTrace();
finally
System.out.println("最终结束");



控制台输出结果如下：
抛出异常MyException 从 f()方法
MyException
at UsingMyException.f(Test.java:10)
at Test.main(Test.java:6)
抛出异常MyException 从 g()方法
MyException: 从g()方法中抛出异常
at UsingMyException.g(Test.java:15)
at Test.main(Test.java:12)
最终结束

JAVA——异常Throwable抛出异常Throws异常处理try-catch制造异常Throw自定义异常类

JAVA——异常Throwable、抛出异常Throws、异常处理try-catch、制造异常Throw、自定义异常类

• 一、概念
• • 1、异常Throwable
  • • （1）Error
    • （2）Exception
  • 2、抛出异常Throws
  • 3、异常处理try-catch
  • 4、制造异常Throw
  • 5、自定义异常类
• 二、应用举例
• • 在使用JDBC操作数据库时的异常处理

一、概念

1、异常Throwable

分类

（1）Error

内存不足，硬盘损坏等问题
举例：
内存溢出错误-OutOfMemoryError
如图所示写了个死循环，一直做字符串拼接，Java程序就会报错，提示内存溢出

（2）Exception

分为：运行时异常（RunTimeException）、非运行时异常
运行时异常举例：
1.算术错误异常-ArithmeticException
0不能作为被除数，不运行时程序逻辑语法是没有问题的，所以不会报错，但运行之后就会报错，提示ArithmeticException，这是Java中自带的异常分类，即告诉我们，出现的异常属于算术错误问题。

2.数组下标越界异常-ArrayIndexOutOfBoundsException
定义了长度为2的数组，然后输出数组中下标为5的元素，超出了数组的长度，所以程序提示ArrayIndexOutOfBoundsException，即，数组下标越界异常

3.空指针异常-NullPointerException
即，找不到对应元素。定义的元素初值为null,这个时候是没办法得到它的长度的，所以会报空指针异常。

4.数据格式转换异常-NumberFormatException

2、抛出异常Throws

例：如果一个方法可能出现异常，就可以用Throws声明，把异常抛给方法的调用者

/**
* 使用throws方法声明该方法有异常，把异常抛给方法的调用者
*/
public static void fun2() throws Exception 
int n = 1/0;

此时如果调用fun(2)方法，就会有异常，如图所示，在fun(1)方法中调用声明了异常的fun(2)方法，方法调用处标红报错了。

如提示所示，有两种处理方式：
第一种：继续向上抛出异常。也就是在方法后加【 throws Exception 】。如图所示，此时fun(2)方法调用处不再标红报错，但如果fun(1)方法被调用，仍然会报错。

第二种：异常处理。方法的异常不能永远往上抛，就需要在某一步使用【try-catch】语法进行异常处理。

3、异常处理try-catch

以上面的例子为例，选择第二种解决方案，使用【try-catch】语法进行异常处理，程序不再报错，如图所示：

完整的异常处理语法是这样的：

try 
			可能出现异常的代码
	catch(要处理的异常类型 参数) 
			如果try出现异常就执行这行带代码
	catch(要处理的异常类型 参数) 
		如果try出现异常就执行这行带代码
	
		...
	finally 
		无论try成不成功，这一行代码都会被执行
	

异常处理的作用是，在程序可能发生异常时，人为地设定另一种方案（即catch大括号里的内容），让程序能够继续走下去，不至于因为某一步的异常导致接下来的程序都无法执行。

4、制造异常Throw

语法：制造非运行时异常，必须加try-catch异常处理，否则会直接编译报错；制造运行时异常，则只有在运行程序时才会报错。

try 
	throw new Exception("我是一个被制造的异常");
catch(Exception e) 
	e.printStackTrace();


throw new RuntimeException("我是一个被制造的运行时异常");

5、自定义异常类

实际开发中，Java中自带的异常类可能不足以满足使用，我们可以通过自定义异常类来解决这个问题。
例如：打游戏这个过程中，可能会发生电脑蓝屏、电脑冒烟两种异常，我们可以自定义这两种异常，代码如下：
电脑蓝屏异常：

电脑冒烟异常：

两个异常类已经定义好了，接着去写一个游戏类，在类里写一个play方法，在调用这个方式打游戏时，会随机产生三种结果：电脑蓝屏、电脑冒烟、打游戏ing…

最后新建一个主类，实例化一个Game对象，调用它的play()方法，测试我们定义的异常是否生效：
第一次点击运行程序：
随机结果是没有产生异常，游戏赢了。

第二次运行，产生了冒烟异常，自定义的异常类MaoYan输出了报错提示：电脑冒烟了

二、应用举例

在使用JDBC操作数据库时的异常处理

使用JDBC操作数据库时，【注册驱动】、【连接数据库】、【sql预编码】、【执行sql】、【关闭连接】这几步，这些方法在在Java源程序中都被声明了异常，即，如果调用这些方法，程序可能发生异常。
如果不进行异常处理，就会产生非运行时异常，即程序直接标红报错，如图所示：

任意选择一个，如【连接数据库】，鼠标放到红框中的getConnection处，按住CTRL键，点击鼠标左键，查看Java源程序中定义的DriverManager类下的getConnection方法，如图所示，被声明了异常：
这是因为连接数据库提供的信息可能有错误，就会连接数据库失败。

那么我们就需要对这些可能产生的异常进行try-catch处理：
加上异常处理之后的代码如图所示，这样即使产生错误，程序也会继续执行，并输出相应的异常信息提示。