Java基础——异常及处理方法

最新推荐文章于 2023-06-25 17:58:26 发布
最新推荐文章于 2023-06-25 17:58:26 发布
阅读量976 收藏 4
点赞数 1
分类专栏： Java基础 文章标签： 异常 异常处理 Exception Java基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sinat_29174099/article/details/46572273
版权

**什么是异常？**让我们先运行一段代码来理解

class Demo
{
	int chuFa(int x,int y)//这是一个除法运算
	{
		return x/y;
	}
}
public class ExceptionDemo {
	public static void main(String[] args) 
	{
		Demo d = new Demo();
		int a = d.chuFa(4,1);//这里传入的除数是1
		System.out.println(a);
		System.out.println("over");
	}
}

运行结果如下：
代码运行结果
而当我把主函数中的除数换成0的话，我们知道在数学中这是没有意义的运算。在Java运行时也会运行失败，提示如下：
出现异常情况
结果表明，在程序运行的过程中出现了不正常的情况，
是什么情况不正常呢？提示中给出，ArithmeticException：/ by zero 算术异常：被0除了

我们把这样在程序中出现的不正常的情况称之为异常。

**异常：**就是程序在运行时出现的不正常情况。
**异常由来：**问题现实生活中一个具体的事物，也可以通过Java类的形式进行描述，并封装成对象。其实就是Java对不正常情况进行描述后的对象体现。（简单说就是把问题封装成了对象）（这里又体现了Java语言的封装性和面向对象的特征）

对于问题的划分，有两种，一种是严重的问题，一种是非严重的问题
对应于严重的，Java通过Error类进行描述

对于非严重的，Java通过Exception类进行描述
对于Exception，一般都会编写针对性的代码进行处理

无论Error还是Exception都具有一些共性的内容。
比如：不正常情况的信息，引发原因等。
所以，Error和Exception都有一个父类叫做Throwable
异常最常见的处理方法如下：

try
{
	需要被检测的代码
}
catch (异常类 变量)
{
	异常的处理方式
}
finally
{
	一定会执行的语句
}

try catch方法处理异常的流程
当出现异常情况后，会创建一个异常对象，这个异常情况被try检测到以后就会抛给catch，catch会做出对应的解决方式，处理完异常以后，之后的代码还可以运行到。把之前的代码加上异常处理机制后就是：

public class ExceptionDemo {
	public static void main(String[] args) 
	{
		Demo d = new Demo();
		try
		{
			int a = d.chuFa(4,0);//这里传入的除数是1
			System.out.println(a);
		}
		catch (Exception e)
		{
			System.out.println("除零啦");
		}
		
		System.out.println("over");
	}
}

运行结果就变成了：异常处理过后的运行结果
从结果中可以看出，异常处理完之后，会继续执行下边的语句

对于异常常见的几种获取信息的方法：
String getMessage();//引发错误的原因
String toString();//异常类+引发错误的原因
void printStackTrace();//异常类+引发错误的原因+追踪错误的位置信息

声明异常用throws关键字

由于在调用方法的时候会有异常发生，导致程序停止，所以在定义方法的时候要用throws关键字声明一下会有异常情况，意思就是告诉调用该方法的人，这个方法可能会发生异常，你需要处理

作用：提高安全性，让调用和作出处理，不处理则编译失败。

对于调用了已声明了异常的方法处理方式
一旦调用了已经声明异常的方法，就必须对其作出处理，否则会编译失败
处理方式有两种：
throws ：抛出，由抛出函数的外层函数进行处理，如果处理不了，再次声明抛出可以继续往外抛，那么，抛到哪里是个头呢？
jvm虚拟机，虚拟机接收到抛出的异常之后，会使用默认的方法，让程序停掉，
try：

多异常的处理方式

  1. 声明异常时，建议声明更为具体的异常，这样处理的可以更具体，
  2. 对方声明几个异常，就 对应有几个catch块。不要定义多余的catc块。
    如果多个catch块中的异常出现继承关系，父类异常catch块放在最下边，如果父类异常catch块放在了最上边，那么虚拟机认为后边的全是废话，编译失败。
    举例如下：
class Demo
{
	int chuFa(int x,int y) throws ArithmeticException,ArrayIndexOutOfBoundsException //在这个方法里声明了两个异常
	{
		int[] arr = new int[x];
		System.out.println(arr[4]);//如果数组角标越界的话会触发角标越界异常
		return x/y;
	}
}
public class ExceptionDemo2 {
	public static void main(String[] args) 
	{


		Demo d = new Demo();
		try{
			int a = d.chuFa(5,1);//这里传入参数容易引发异常
			System.out.println(a);
		}


		catch(ArithmeticException e)//触发ArithmeticException异常的时候执行的代码块
		{
			System.out.println("除零了");
		}
		catch(ArrayIndexOutOfBoundsException e)//触发ArrayIndexOutOfBoundsException异常的时候执行的代码块
		{
			System.out.println("角标越界啦");
		}
		catch(Exception e)//这是父类异常的代码块
		{
			System.out.println("hahaha："+e.toString());
		}
		System.out.println("over");
	}
}

这个时候没有发生任何异常，运行会正常结束：
正常运行结果
当把chuFa方法中的参数改为4,1时（创建一个角标越界的异常）结果如下：
角标越界异常
当把参数改为5，0时，（创建一个运算异常） 结果如下：
运算除零异常
我们可以看到，放在最下边的catch块，虽然是每个异常的父类，但并没有执行，

因为代码是从上到下执行的，找到了符合条件的catch块，就不会去找其他的catch块，这样写父类的异常catch块是为了避免其他异常蹦出来中断程序，可以编译通过，也可以运行但是不建议这么写，因为在运行过程中出了啥异常都会被父类异常处理掉，如果出现了别的异常，程序员需要知道；

建议：在进行异常处理时，catch中一定要有具体的定义方式，不要简单的定义一句打印异常信息，也不要简单的书写一条输出语句

自定义异常
在后期做开发的时候，描述具体的事物有具体的要求，也就是说会遇到不同的异常，而这些是Java没有进行过描述并封装对象的

所以，对于这些特有的问题，我们可以按照Java的封装思想，将特有的问题进行自定义的异常封装。

怎么样进行异常的封装呢？我们用代码来体现：

//需求：定义一个除法运算，除了不能除零外，还要定义不能除以负数

class FuShuException extends Exception//定义一个异常类（对象），需要继承Exception
{
	private int value;//想把出错误的数字也获取到，在这里创建一个value
	
	FuShuException(String msg,int b)//因为自定义异常还没有定义自己的异常信息，所以在初始化的时候就要传一个描述性的文字，作为他的异常信息描述语句
	{
		
		super(msg);	
		//Exception类中已经定义了自定义异常信息的方法，这里把参数传给父类Exception就行了
								//下边调用toString方法的时候会自动调用getMessage方法，将描述语句打印出来
		this.value = b;
		
	}
	public int getValue()
	{
		return value;
	}
}
class Demo
{
	int chuFa(int x,int y) throws FuShuException,ArithmeticException
	{
		if (y<0)//除数小于0，创建异常对象并抛出
		{
			throw new FuShuException("除数为负数了 / by fushu",y);
		}
		return x/y;
	}
}
public class ExceptionDemo3 {
	public static void main(String[] args) 
	{
		Demo d = new Demo();
		try//对自定义的异常进行处理
		{
			int a = d.chuFa(4,-1);
			System.out.println(a);
		}
		catch (FuShuException e)
		{
			System.out.println(e.toString()+"---错误的数字是"+e.getValue());
		}
		catch(ArithmeticException e)
		{
			System.out.println(e.toString());
		}

	}
}

运行结果为：
自定义异常运行结果
我们可以看到，自定义异常，必须是自定义类继承Exception

继承Exception 的原因：
异常体系中有一个特点，因为异常类和对象都被抛出
他们都具备可抛性。这个可抛性是Throwable这个体系中的独有特点

注意的是，在自定义异常的时候，没有必要所有的信息都自己去做，
比如异常信息的操作，在父类中就已经做完了，父类中有这样的方法：
Throwable中的构造方法摘要
而在Exception类中，也有相同的方法：
这里写图片描述
所以我们这里只要把自定义的信息用super语句传给父类。
就是以上代码中的 “super(msg);”
就可以直接通过getMessage方法获取自定义的异常信息。

throw和throws的区别
throws使用在函数上，throw使用在函数内
throws后边跟的是异常类，可以跟多个，用逗号隔开
throw后跟的是异常对象

运行时异常
Exception中有一个特殊的子类异常RuntimeException

如果在函数中抛出该异常，函数上可以不用声明，编译一样通过。
如果在函数上声明了该异常，调用者可以不用进行处理，编译一样通过。

之所以不用在函数声明，是因为不需要让调用者处理
当该异常发生，希望程序停止，因为在运行时，出现了无法继续运算的情况，希望程序停止后，对代码进行修正。

子类例如：数组角标越界异常（角标越界都找不到元素，没有办法继续运算下去了），空指针异常（对象没有指向的示例化对象，也无法进行下一步的运算）

这些情况下，我们希望程序停下来，不希望catch处理之后继续再进行运算，
因为再运算也没有什么意义了。

用一段小代码来具体体现一下RunTimeException的特点：

//运行时异常：

//需求：定义一个除法运算，除了不能除零外，还要定义不能除以负数
		//一旦发生除零，除负数的情况，应该让程序停下来，因为继续算也没什么 意义了

class FuShuException extends RuntimeException//该种异常我们不会处理，发生该异常的时候希望程序停下来，所以这里要继承RunTimeException
{
	
	FuShuException(String msg)
	{
		super(msg);	
	}
	
}
class Demo
{
	int chuFa(int x,int y)//因为里边抛出的是RunTimeException，所以在这里可以不用声明，在主函数中也不用处理
	{
		if (y<0)
		{
			throw new FuShuException("除数为负数了 / by fushu");
		}
		if (y==0)
		{
			throw new ArithmeticException("除数为0，没意义");
		}
		return x/y;
	}
}
public class ExceptionDemo4 {
	public static void main(String[] args) 
	{
		Demo d = new Demo();
		
			int a = d.chuFa(4,0);
			System.out.println(a);

	}
}

运行结果为下图：
运行时异常代码运行结果

在自定义异常的时候：如果该异常的发生无法再继续进行运算，就让自定义异常继承RunTimeException。

对于异常分为两种：
1，编译时被检测的异常。
2，编译时不被检测的异常（运行时异常，RunTimeException以及其子类）

所以在分析问题定义异常的时候，先要分析该异常能不能被处理，
|-----如果不能处理，需要修正代码的时候，就继承RunTimeException，
|-----如果该异常可以被try catch处理，就继承Exception。

一个小练习：老师带电脑上课的过程中异常处理：

//异常练习
/*
需求：毕老师讲课，要用电脑讲课，

而会时常有异常，比如：电脑蓝屏了，：处理方式，重启，继续上课

					  电脑冒烟了。：处理方式，又有了一个新的异常：
							课时无法完成，处理方式：换老师或者放假


思想：封装，将各种异常封装成对象，关键字提取；

*/

class LanPingException extends Exception//蓝屏异常
{
	LanPingException(String msg)
	{
		super(msg);
	}
}
class MaoYanException extends Exception//冒烟异常
{
	MaoYanException(String msg)
	{
		super(msg);
	}
}
class NoPlanException extends Exception//课时无法继续异常
{
	NoPlanException(String msg)
	{
		super(msg);
	}
}
class Teacher
{
	private String name;
	Teacher(String name)
	{
		this.name = name;
	}
	public void jiangKe() throws NoPlanException//老师讲课过程中会抛出课时无法继续异常，所以在这里标识一下

	{
		//老师来讲课，带上了自己的电脑，开启电脑之后开始讲课
		Computer cmpt = new Computer();
		try
		{
			cmpt.run();//而电脑会出现异常，所以在这里调用run方法的时候要对异常进行处理
		}
		catch (LanPingException e)
		{
			cmpt.restart();
		}
		catch (MaoYanException e)
		{
			//发生冒烟异常的时候，处理方法应该是先让学生们做练习，然后给调用讲课方法的人抛一个课时无法完成异常
			//交给上一层领导处理
			test();
			throw new NoPlanException("课时无法继续");
		}
		System.out.println("开始讲课");
		
	}
	public void test()
	{
		System.out.println("做练习");
	}
}
class Computer
{
	private int state = 3;
	public void run() throws MaoYanException,LanPingException
	{
		//电脑的诸多自定义异常都要在这里产生异常对象
		if(state==2)
		{
			throw new LanPingException("蓝屏了");
		}
		if (state==3)
		{
			throw new MaoYanException("冒烟了");
		}
		System.out.println("电脑运行");
	}
	public void restart()
	{
		System.out.println("电脑重启");
	}
}
public class ExceptionTest{
	public static void main(String[] args) 
	{
		Teacher t = new Teacher("毕老师");
		try
		{
			t.jiangKe();//在调用讲课方法的时候，接收到课时无法完成异常，将在这里进行处理
		}
		catch (NoPlanException e)
		{
			System.out.println("换老师或者放假-----"+e.getMessage());
		}
		
	}
}

运行结果如下：
当代码中state为1的时候（电脑没有发生任何异常的时候）结果为：
无异常运行结果

当代码中state为2的时候（电脑发生蓝屏异常的时候）结果为：
蓝屏异常运行结果

当代码中state为3的时候（电脑发生冒烟异常的时候）结果为：
冒烟异常运行结果

异常——finally

finally代码块，定义一定会执行的代码，通常用于关闭资源

在数据库操作中最为常见的例子：

public void method()
{
	连接数据库；
	
	数据操作//throw new SQLException如果抛出异常，下面的代码就不会运行了，也就是说资源没有被关闭，
	
	关闭数据库//而这一步是必须要执行的
}

该代码中如果异常出现，则不会关闭资源，这不是我们想要的。
解决这样的问题可以这么做：

public void method() throws 没有操作成功异常
{
	try
	{
		连接数据库；
		数据操作；//throw new 数据操作异常；
	}
	catch(数据操作异常 e)
	{
		会对数据库异常进行处理；
		throw new 没有操作成功异常；
	}
	finally
	{
		关闭数据库；
	}
}

在Java中，数据存储操作是调用数据库的方法完成的，
我要存数数据，把数据给你即可，至于你是怎么存的，我没必要知道，
但是我必须知道的是：数据有没有存储成功，

就像在以上的代码中，数据库操作出现异常，应该在数据库内部直接处理，
而不是抛出来异常，因为抛出来我也看不懂，所以在你内部直接处理掉就可以了。
但是你要告诉我，有没有存储成功，也就是说这里可以抛出来一个“没有操作成功异常”这个我可以处理。

而不管有没有存储成功，资源是必须要关闭的，所以我们在这里把关闭资源的动作放在finally语句中。

异常处理语句的其他格式：

//第一种格式：
try
{
}
catch()
{
}
//第二种格式：
try
{
}
caatch()
{
}
finally
{
}
//第三种格式
try
{
}
finally
{
}

记住一点：catch是用来处理异常的，如果没有catch代表该异常没有被处理过，如果该异常时检测时异常，那么必须申明。

异常在子父类覆盖中的体现

  1. 子类在覆盖父类时，如果父类的方法抛出异常，那么子类的覆盖方法只能抛出父类的异常，或者父类异常的子类，
  2. 如果父类方法抛出多个异常，那么子类在覆盖该方法时，只能抛出父类异常的子集。
  3. 如果父类或者接口的方法中没有异常抛出，那么子类在覆盖方法时，也不可以抛出异常。如果子类方法抛出了异常吗，就必须要进行try处理，绝对不能抛。

用一个代码练习来说明这段文字：

//异常之间的关系是：
//   |--Exception
//      |--AException
//			|--BException
//		|--CException
class AException extends Exception
{

}
class BException extends AException
{

}
class CException extends Exception
{

}


class Fu 
{
	public void show() throws AException//父类方法抛出一个AException
	{
	}
}
class Zi extends Fu//子类继承父类
{
	public void show()throws BException//在这里抛出一个AException(也可以抛出BException，但是不能抛出CException)
										//如果这里真的会冒出一个C异常的话，只能try，绝对不能抛
	{

	}
}
class Test1
{
	public void function(Fu f)
	{
		try
		{
			f.show();
		}
		catch (AException e)
		{

		}
		
	}
}
public class Test {
	public static void main(String[] args)
	{
		
		Test1 t1 = new Test1();
		t1.function(new Zi());
	}
}

通过一串小代码来更加熟练的运用一下异常的处理机制：

//长方形圆形的面积计算程序


/*
首先思考：长方形，圆形都是图形，都有获取面积的这样一个功能，
但是长和宽是长方形特有的，半径是圆特有的属性
可以将获取面积的方法封装在一个接口中
*/
interface Shape
{
	void getArea();
}
//长方形的计算过程：
class ChangFangXing implements Shape
{
	private int chang;
	private int kuang;
	ChangFangXing(int chang,int kuang)
	{
		this.chang = chang;
		this.kuang = kuang;
	}
	public void getArea()
	{
		//如果给出的值小于0的话，必须停掉程序，不可以再往下运行了。
		if (chang<=0 || kuang<=0)
		{
			throw new NoValueException("长或宽的值小于0！！！");
		}
		System.out.println(chang*kuang);
	}

}
//圆的面积计算过程：
class Yuan implements Shape
{
	private int radiu;
	//PI的值是不变的，所以在这里把他定义成常量
	public static final double PI = 3.14;
	Yuan(int radiu)
	{
		this.radiu = radiu;
	}
	public void getArea()
	{
		//同样的，如果他的半径小于0，程序停掉
		if (radiu<=0)
		{
			throw new NoRadiuException("圆的半径值出错！！！");
		}
		System.out.println(radiu*radiu*PI);
	}
}
class NoValueException extends RuntimeException
{
	NoValueException(String msg)
	{
		super(msg);
	}
}
class NoRadiuException extends RuntimeException
{
	NoRadiuException(String msg)
	{
		super(msg);
	}
}
public class ExceptionTest2 {
	public static void main(String[] args) 
	{
		//创建一个长方形对象，求面积
		ChangFangXing cfx = new ChangFangXing(3,4);
		cfx.getArea();
		//创建一个圆的对象，并求面积
		Yuan y = new Yuan(2);
		y.getArea();
	}
}

运算结果为：
面积运算程序结果

异常知识总结：

  • 异常是什么？
    • 是对问题的描述，并将问题对象封装成对象
  • 异常体系：
    • Throwable
      • Error
      • Exception
        • RuntimeException
  • 异常体系的特点：异常体系中所有类以及建立的对象都具有可抛性。也就是说可以被throw和throws关键字操作，只有异常体系具备这个特点。
  • throw和throws的用法：
    • throw定义在函数内，用于抛出异常对象
    • throws定义在函数上，用于抛出异常类，可以抛出多个，用逗号隔开。
  • 当函数内容有throw抛出异常对象，并未进行try处理，必须要在函数上声明，否则编译失败
  • 注意：RunTimeException除外，也就是说，函数中如果抛出RunTimeException函数上可以不用声明
  • 如果函数上声明了异常，调用者需要进行处理。处理方法可以是try和throws
  • 异常有两种：
    • 编译时被检测异常
      • 该异常在编译时，如果没有进行过处理（没有抛也没有try），编译失败
      • 该异常被标识，代表着可以被处理
    • 运行时异常（编译时不检测）
      • 在编译时，不需要处理，编译器不检查。
      • 该异常发射给你时，建议不处理，让程序停止，需要对代码进行修正
  • 异常处理语句：
    try
    {
    需要被检测的代码；
    }
    catch（）
    {
    处理异常的代码；
    }
    finally
    {
    一定会执行的代码；
    }
    有三个结合方式：
    1.try catch
    2.try finally
    3.try catch finally
  • 注意：
    • finally中通常是关闭资源的代码，因为资源必须释放
    • finally只有一种情况不会执行，当执行到System.exit(0)；finally不会执行，因为jvm结束运行了
  • 自定义异常：
    • 定义类继承Exception或者RuntimeException
    • 1.为了让该自定义类具备可抛性。
    • 2.让该类具备操作异常的共性方法
    • 3.当要定义自定义异常信息时，可以使用父类已经定义好的功能。将异常信息传递给父类的构造函数
class MyException extends Exception
{
	MyException(String message)
	{
		super(message);
	}
}
  • 自定义异常：按照Java面向对象的思想，将程序中出现的特有问题进行封装
  • 异常的好处：
    • 将问题进行封装。
    • 将正常流程代码和问题处理代码相分离，方便于阅读。
  • 异常的处理原则：
    • 1，处理方式有两种：try 或者throws
    • 2，调用到抛出异常的功能时，抛出几个，就处理几个。
      • 一个try对应多个catch
    • 3，多个catch，父类的catch放到最下边
    • 4，catch内，不需要定义针对性的处理方式，不要简单的定义printstrackTrace,也不要不写
      • 当捕获到的异常，本功能处理不了时，可以继续在catch中抛出。
try
{
	throw new AException();
}
catch(AException e)
{
	throw e
}

如果该异常处理不了，但并不属于该功能出现的异常。
可以将异常转换后，再抛出和该功能相关的异常。
或者异常可以处理，但需要将异常产生的和本功能相关的问题提供出来
让调用者知道，并处理，也可以将捕获异常处理后，转换新的异常抛出

try
{
	throw new AException();
}
catch(AException e )
{
	//对AException处理。
	throw new BException();
}

比如：汇款的例子。
我去给张三汇款，但是出了异常没有汇成功，汇款机需要先将我汇的钱再存进我的卡里，然后告诉我，没有汇成功，我再去处理这个没有汇成功的异常（换个银行或者换台机子）

  • 异常的注意事项：
    • 在子父类覆盖时：
    • 1，子类抛出的异常必须是父类的异常或者异常的子类，或者子集
    • 2，如果父类或者接口没有异常抛出时，子类覆盖出现异常，只能try不能throws
      参阅例子：
      老师用电脑上课
      图形面积
下山打老虎◆
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java基础——方法
qq_56609066的博客
08-04 215
Java基础——方法
Java基础--异常处理
qq_36906588的博客
12-16 269
Java异常的简介和异常的处理方法
java异常处理
niceffking的博客
11-30 5707
什么是异常 异常处理 如何捕捉异常？ finally语句 常见异常 自定义异常 那么具体如何自定义异常类呢？ throw关键字 throws关键字 运行时异常 异常处理流程
java中的异常处理
热门推荐
weixin_45581692的博客
07-17 1万+
异常的作用增强程序的健壮性。java中异常以什么形式存在？异常在java中以类的形式存在，每一个异常类都可以创建异常对象。JVM执行到某一处觉得有异常，会new异常对象，并且将new的异常对象抛出，打印输出信息到控制台了。如异常对应的现实生活火灾（异常类）2008年8月8日，小明家着火了（异常对象）2008年8月9日，小红家着火了（异常对象）异常体系结构注意所有异常都是在运行阶段发生的，因为只有程序运行阶段才可以new对象，因为异常的发生就是new异常对象。第一种方式。......
JAVA中的异常处理
weixin_73986007的博客
05-20 1403
异常和异常处理
一次搞懂Java异常处理(超详细!!!)！
weixin_53622554的博客
03-17 7834
Java标准库中提供了非常多表的异常类型，用来表达各种异常情况，然而在真实开发中，这些异常并不能完全满足我们的需求，因为标准库的异常往往表达的是技术层面，而不是业务层面，像账号密码错误这种情况，用标准库的异常就不太合适，所以在开发中我们会自定义异常类型，来表达符合我们业务的异常情况。finally一般作用在try-catch代码块中，在处理异常的时候，通常我们将一定要执行的代码方法放入finally代码块中，表示不管是否出现异常，该代码块都会执行，一般用来存放一些关闭资源的代码。
Java——异常处理（详解）
guochaoHNU的博客
09-30 2502
目录定义概念：异常类型异常处理：try...catchtry...catch finally 定义概念： 所谓异常就是程序运行时可能出现的一些错误，比如试图打开一个根本不存在的文件、配置问题、错误输入等问题，异常处理将会改变程序的控制流程，让程序有机会对错误做出处理。语法错误和逻辑错误不是异常。 java异常处理过程： （1）当程序运行到某一句时，发生了异常，那么程序会先停下来 （2）程序会在这句代码处，查看原因，生成一个合理“异常对象”，然后“抛”出 （3）JVM会检测在这句代码的外围，是否有try…c
Java提高篇——Java异常处理
02-24
本文来自于cnblogs,文章主要从基础概念说起，又讲解了体系结构，Java的异常处理机制，异常链等相关，详细内容请看下文。异常是程序中的一些错误，但并不是所有的错误都是异常，并且错误有时候是可以避免的。比如说，...
尚硅谷Java基础实战——Bank项目下载地址
12-29
这个项目以银行系统为背景，涵盖了诸多Java基础知识点，包括类与对象、数据类型、控制结构、异常处理、集合框架、IO流等。 1. 类与对象：在Bank项目中，你会遇到各种类，如Bank、Account、Customer等，这些都是模拟...
java基础——方法的重写、多态+instanceof（csdn）————程序.pdf
12-01
在Java编程语言中，方法的重写和多态是面向对象设计的重要概念，它们使得代码更加灵活和可扩展。下面将详细阐述这两个概念及其应用场景。 首先，方法的重写（Override）是指在一个子类中定义与父类相同名称和参数...
Java基础学习/高级类/异常处理/线程
03-06
本篇将重点探讨"Java基础学习/高级类/异常处理/线程"这四个关键知识点。 一、Java基础学习 Java的基础学习涵盖了许多方面，包括语法、数据类型、控制结构、类和对象等。初学者应首先掌握Java的基本语法，例如变量...
个人学习的java笔记——思维导图
01-25
4. **异常处理**：Java提供了异常处理机制，通过try-catch-finally语句块来捕获和处理运行时错误，确保程序的健壮性。 5. **集合框架**：Java集合框架包括List、Set、Map等接口以及ArrayList、HashSet、HashMap等...
20个Java异常处理的方式
huang714的专栏
06-02 4570
public void foo() throws Exception { //错误方式一定要避免出现上面的代码，它破坏了检查性（checked）异常的目的。声明的方法应该尽可能抛出具体的检查性异常。例如，如果一个方法可能会抛出 SQLException 异常，应该显式地声明抛出 SQLException 而不是 Exception 类型的异常。这样可以让其他开发者更好地理解代码的意图和异常处理的方式，并且可以根据 SQLException 的定义和文档来确定异常的处理方式和策略。//错误方式。
java异常除法运算的处理
weixin_42843651的博客
07-31 4530
import java.util.Scanner; public class Test1 { public static void main(String[] args) { Scanner in = new Scanner(System.in); System.out.println(“请输入被除数”); int num1 = in.nextInt(); try{ System.o...
【Java基础篇】Java异常篇
输入技术、输出想法
05-27 1622
java异常篇Java 异常处理Exception 类的层次Java 内置异常类异常方法捕获异常throws/throw 关键字finally关键字声明自定义异常通用异常final、 finally、 finalize 的区别？ Java 异常处理 异常是程序中的一些错误，但并不是所有的错误都是异常，并且错误有时候是可以避免的。 比如说，你的代码少了一个分号，那么运行出来结果是提示是错误java.lang.Error；如果你用System.out.println(11/0)，那么你是因为你用0做了除数，会抛
Java中的异常处理
weixin_64189867的博客
06-02 452
在使用计算机语言进行项目开发的过程中，即使程序员把代码写得尽善尽美，在系统的运行过程中仍然会遇到一些问题，因为很多问题不是靠代码能够避免的，比如：客户输入数据的格式，读取文件是否存在，网络是否始终保持通畅等等。自定义异常就是自己定义的异常类，也就是API中的标准异常类的直接或间接的子类。作用：用自定义异常标记业务逻辑的异常，避免与标准异常混淆。自定义异常类基本语法public class 异常类名 extends Exception/RuntimeException{
【Java 基础篇】Java 异常处理详解
最新发布
繁依Fanyi的博客
06-25 1213
本文详细介绍了 Java 异常的概念、类型、处理方式和最佳实践。了解和掌握异常处理机制对于开发高质量的 Java 应用程序至关重要。在编写代码时，合理处理异常并提供适当的错误信息可以提高程序的可靠性和可维护性。希望本文对你理解和应用 Java 异常处理有所帮助。如果你对异常处理还有更多疑问，可以查阅 Java 官方文档或参考相关书籍进行深入学习。附：示例代码try {// 执行读取文件的操作 } catch(IOException e) {= null) {try {try {
Java面向对象与异常处理详解：提升软件设计效率
Java面向对象及异常处理是现代软件开发的核心概念，它在Java编程中扮演着至关重要的角色。本文档深入探讨了这一主题，包括以下几个关键知识点： 1. **面向对象思想**： 面向对象编程(OOP)与面向过程编程相比，更...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值