Java15异常处理

最新推荐文章于 2024-10-30 13:17:13 发布

YanQ要自律

最新推荐文章于 2024-10-30 13:17:13 发布

阅读量5.9k

点赞数 1

分类专栏：简单题 Java错题文章标签： java

本文链接：https://blog.csdn.net/ChenYanQing666/article/details/123884914

版权

简单题同时被 2 个专栏收录

16 篇文章

订阅专栏

Java错题

11 篇文章

订阅专栏

本文介绍了Java异常处理的相关知识，包括选择题、判断题、填空题和编程题，涉及异常的抛出、捕获、finally语句的使用、自定义异常类以及异常处理的必要性和方式。同时，讲解了运行时异常、受检查异常的区别，throw关键字的应用，并给出了自定义异常类的示例。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Java异常处理

**
一。选择题
1、 java中用来抛出异常的关键字是（） throw
2、在异常处理中，如释放资源、关闭文件、关闭数据库等由( )来完成。 finally子句
3、当方法遇到异常又不知如何处理时，下列哪种说法是正确的( ) [单选题]
正确答案： C、声明异常！！

二。判断题(共4题)
1、程序中抛出异常时(throw …)，只能抛出自己定义的异常对象。错误
2、一个异常处理中 finally语句块只能有一个或者可以没有。正确
3、 java语言中的所有异常类都是java.lang.Throwable的子类正确
4、如果异常发生时，没有捕获异常的代码，程序会正常执行。错误
三、填空题
1、下面程序抛出了一个“异常”并捕捉它。请在横线处填入适当内容完成程序。

class TrowsDemo
{
  static void procedure() throws IllegalAccessExcepton
  {
    System.out.println(“inside procedure”);
    throw （） IllegalAccessException(“demo”);
  }
 public static void main(String args[]){
     try
      {
        procedure();
      }
      （）
      {
        System.out.println(“捕获：”+e);
      }
  }

正确答案： new,catch(IllegalAccessException e)
四、简答题(共3题)

1、【编程题】写代码，再main()方法中调用类CCircle中的方法，计算圆的面积。并且自己定义一个异常类，如果半径为负值，抛出自己定义的异常。（在类CCircle中判断并抛出异常）

public class Circle {
	private double r;	
	public Circle(double r) throws CircleException {
		if(r<0) {
			throw new CircleException("半径为负数");
		}
		this.r = r;
	}
	public static void main(String[] args) {
		try {
			Circle c = new Circle(-1);
		} catch (CircleException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}
class CircleException extends Exception{
	public CircleException(String msg) {
		super(msg);
	}
}

2、【编程题】自定义类Sanj，其中有成员 x,y,z,作为三边长，构造方法Sanj(a,b,c)分别给x,y,z赋值,
方法求面积getArea和显示三角形信息(三个边长)showInfo，这2个方法中当三条边不能构成一个三角形时要抛出自定义异常NotSanjiaoException，否则显示正确信息。
在另外一个类中的主方法中构造一个Sanj对象(三边为命令行输入的三个整数)，显示三角形信息和面积，要求捕获异常

public class Sanj {
	int x;
	int y;
	int z;
	public Sanj(int x,int y,int z) {
		this.x=x;
		this.y=y;
		this.z=z;
	}
	public void sanj()throws notsanjiaowxception{
		double area;
		double a;
		if(x+y>z&&x+z>y&&z+y>x) {
			area=Math.sqrt(((x+y+z)/2)*((x+y+z)/2-x)*((x+y+z)/2-y)*((x+y+z)/2-z));;
			System.out.println("三边分别为："+x+" "+y+" "+z);
			System.out.println("面积为："+area);
		}
		else {
			throw new notsanjiaowxception(x, y, z);
		}
	}
}


public class notsanjiaowxception extends Exception{
    int x;
    int y;
    int z;
    public  notsanjiaowxception(int x,int y,int z){
        this.x=x;
        this.y=y;
        this.z=z;
    }
    public void not(){
        System.out.println("不能构成三角形");
    }
}

public class Test1 {
	public static void main(String[] args) {
        Sanj s=new Sanj(1,1,3);
        try {
            s.sanj();
        }catch (notsanjiaowxception n){
            n.not();
        }
    }
}

3、【编程题】编写如下异常类：
空异常，年龄低异常，年龄高异常，工资低异常，工资高异常，身份证非法异常(自定义异常)。
编写一个员工类，
(1) 有属性：
编号，姓名，年龄，工资，身份证号码，员工人数，员工工资总额
(2) 有构造器：
构造器1：设置编号，年龄，姓名；如果年龄小于18，抛出年龄低异常；如果年龄大于60抛出年龄高异常，如果姓名为null或为空字符串，抛出空异常。
构造器2：设置工资，设置身份证号码；如果工资低于600，抛出工资低异常。
(3) 有方法
增加工资 addSalary(double addSalary)，抛出工资高异常，当增加后的工资大于员工工资总额时，抛出此异常。
减少工资 minusSalary(double minusSalary), 抛出工资低异常，当减少后的工资低于政府最低工资时，抛出工资低异常。
显示员工工资总额方法：showTotalSalary(), 抛出空异常，当工资总额为0时，抛出此异常。
显示员工人数：void showTotalEmployee（），抛出空异常。当员工人数为0时，抛出此异常。
编写Main主测试类：Test
分别生成3个员工，测试构造方法的异常抛出。
每个员工分别增加，减少工资，测试方法的异常。
显示员工的人数和工资总额。

package com.Test12;
//首先创建6个异常类
class LowAgeException extends Exception{
	public LowAgeException(String message) {
		super(message);
	}
}
class HeightAgeException extends Exception{
	public HeightAgeException(String message) {
		super(message);
	}
}
class NullException extends Exception{
	public NullException(String message) {
		super(message);
	}
}
class LowSalaryException extends Exception{
	public LowSalaryException(String message) {
		super(message);
	}
}
class HighSalaryException extends Exception{
	public HighSalaryException(String message) {
		super(message);
	}
}
class IdCardException extends Exception{
	public IdCardException(String message) {
		super(message);
	}
}
//员工类
class Employee{
    private int id;
    private String name;
    private int age;
    private double salary;
    private String idCard;
    private int totalEmployee = 10;
    private double totalSalary = 100000;
    public Employee(int id,String name,int age)throws Exception{
    	if(age<18) {
    		throw new LowAgeException("年龄太小了!");
    	}else if(age>60) {
    		throw new HeightAgeException("年龄太高了!");
    	}else if((name==null)||name==""){
    		throw new NullException("姓名不能为空!");
    	}
    }
    public Employee(double salary,String idCard) throws Exception{
    	this.salary=salary;
    	if(salary<600) {
    		throw new LowSalaryException("工资太低了!");
    	}else if(idCard.length()!=18) {
    		throw new IdCardException("身份证非法!");
    	}
    }
    //增加工资
    public void addSalary(double addSalary) throws Exception{
    	double nowSalary=salary+addSalary;
    	System.out.println("增加后的工资是:"+nowSalary);
    	if(nowSalary>totalSalary) {
    		throw new HighSalaryException("工资增加后太高了!");
    	}
    }
    //减少工资
    public void minusSalary(double minusSalary) throws Exception{
    	double nowSalary=salary-minusSalary;
    	System.out.println("减少后的工资是:"+nowSalary);
    	if(nowSalary<600) {
    		throw new HighSalaryException("工资减少后太低了!");
    	}
    }
    //显示员工工资总额
    public void showTotalSalary()throws Exception {
    	if(totalSalary==0) {
    		throw new IdCardException("工资总额为0!");
    	}
    }
    //显示员工人数
    public void showTotalEmployee()throws Exception {
    	if(totalEmployee==0) {
    		throw new IdCardException("员工人数为0!");
    	}
    }
}
 
public class Test12_6 {
	public static void main(String[] args) {
		try {
			Employee e1=new Employee(201801,"小青",26);
			Employee e2=new Employee(655,"123456789987654321");
			e2.addSalary(1000);
			e2.minusSalary(100);
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			System.out.println("欢迎使用本系统！");
		}
	}
}

异常和错误
异常：当程序运行的过程中，用户输入了一些不合法的数据，或在某个特定的环境出现错误，是异常。
错误：可能是编程时的语法错误，可能是系统内部错误。
异常的类图
Throwable 的子类包括Error和Exception ，Exception的子类中，有一个类是RuntimeException是运行时异常类
Error：JVM系统内部错误、资源耗尽等严重情况。一般情况下，程序员不处理Error的问题的。
Exception: 其它因编程错误或偶然的外在因素导致的一般性问题。程序员是要处理的。
为什么要处理异常

程序出现了异常，程序将不能顺利的执行。因此要对出现的异常进行处理。
程序出现了异常，为了给用户做一些错误的提示及操作的引导。因此要处理异常。

处理异常
有两种处理异常的方式，分别是try-catch-finally 和 throws
1. try-catch-finally处理异常
语法：
try{
可能会出现异常的语句；
}catch(异常类型引用名){
处理异常执行的代码
}finally{
一定会被执行的代码
}

try-catch代码的执行顺序
在try中没有捕获到异常，不会执行到catch中的；
在try中捕获到了异常，立刻执行catch中的代码，catch执行完毕后，try-catch语句执行结束。
try可以有多个catch，每个catch中的异常类型不同，会根据捕获的异常类型，执行对应的catch
多个catch中如果有父类异常类型，要写在子类异常类型的后面

public static void main(String[] args) { 
	//计算两个数相除的程序 
	Scanner scanner = new Scanner(System.in); 
	int i = scanner.nextInt(); 
	int j = scanner.nextInt(); 
	int index = scanner.nextInt(); 
	String[] strs = {"ab","cd"}; 
	try {
		System.out.println(i / j); 
		System.out.println("计算完成"); 
		System.out.println(strs[index]); 
		System.out.println("数组元素显示完成"); 
	}
	catch (
		ArithmeticException e){ 
		//写什么？ 
		e.printStackTrace(); //打印异常的信息 
		System.out.println("除数不能为0"); 
		}catch (ArrayIndexOutOfBoundsException e2){ 
			e2.printStackTrace(); //打印异常的信息 		
			System.out.println("索引超出范围"); 
		}catch (Exception e){
		 }
		 System.out.println("再见"); }

可以写try-catch组合；可以写try-catch-finally组合；可以写try-finally组合。
finally语句块代表一定会被执行的代码，一般在finally中写一下关闭/释放资源的代码。

2. throws处理异常
把异常抛给调用者
语法：在方法参数括号的后面 throws 异常类型
在构造器参数括号的后面 throws 异常类型

public class FileDownLoad { 
	public void download(String path) throws FileNotFoundException { 
	//获得文件对象，想到了一个问题，调用者给我的路径有没有可能文件不存在 
	//知不知道怎么处理 文件找不到异常 
	FileInputStream fis = new FileInputStream(path); 
	} 
	}

public class WebFileDown { 
	public void webdown(){ 
		FileDownLoad fileDownLoad = new FileDownLoad();
		try {
			fileDownLoad.download("d:/a.txt"); 
		}catch (FileNotFoundException e){
			 System.out.println("文件不存在"); 
			 } 
			 } 
			 }

当不知道异常如何处理，使用throws抛出异常；当知道如何处理异常时，使用try-catch处理异常
Exception的分类

运行时异常：异常发生在运行期的，RuntimeException下的子类都是运行时异常，例如：
NullPointerException、ClassCastException、ArrayIndexOutOfBoundsException、
ArithMeticException、NumberFormatException。通常情况，运行时异常不需要处理，通过代码来避免。
受检查异常/编译期异常：异常发生在编译期，如果不对异常处理，程序将不能编译。

Throw关键字
将异常对象抛到程序中。
语法： throw 异常对象
在一个方法或构造器中执行到了throw 异常对象语句，方法或构造器执行结束了

public FileDownLoad(String path) throws FileNotFoundException { 
	if(path==null||"".equals(path)){
		 //异常的出现 
		 //1. JVM创建了异常对象，异常抛到代码中 
		 //2. 编程主动创建异常对象，抛到代码中 
		 throw new FileNotFoundException();
		  }
		 }

自定义异常
JDK中提供了很多异常类，但开发时要使用一些自己特定的异常，例如：邮箱地址不存在异常、QQ号不存在异常、微信无法登录异常。这种异常需要自定义异常类了
自定义一个类，这个类要具有异常类的所有功能。使用继承来自定义
示例：
需求：开发一套制作邮件系统的框架，其中一个类实现邮件的发送功能。当程序员调用发送功能时，抛出一个邮件地址不存在的受检查异常，调用者处理这个异常。

自定义邮件地址不存的异常类

public class EmailAddressNotFoundException extends Exception{ 
	//每个异常类中 都有一个message属性，在打印异常信息时 冒号的后面就是message的内容 
	public EmailAddressNotFoundException(String message){ 
		super(message); 
		} }

实现邮件发送功能类

public class EmailManager { 
	/**
	* 发送邮件方法 
	*/ 
	public void send(String address,String title,String content) throws	EmailAddressNotFoundException {
		 //可能会出现邮件地址不存在异常 
		 if(address==null||"".equals(address)){ 
		 	throw new EmailAddressNotFoundException("邮件地址不存在"); 
		 	}
		 	//
		 	System.out.println("发送邮件成功"); 
		 	} 
		 	}

调用邮件发送功能，出现受检查异常(EmailAddressNotFoundException)

public static void main(String[] args) { 
	//OA项目 设计邮件发送 
	EmailManager emailManager = new EmailManager(); 
	try {
		emailManager.send("","xxx","xxxx..."); 
	} catch (EmailAddressNotFoundException e) { 
		e.printStackTrace(); 
		} 
		}