Java开发必备点16_异常

最新推荐文章于 2024-06-10 21:57:08 发布

炳烛之明科技

最新推荐文章于 2024-06-10 21:57:08 发布

阅读量68

点赞数

分类专栏： CoreJava 文章标签： java

本文链接：https://blog.csdn.net/qq_40828705/article/details/117431618

版权

CoreJava 专栏收录该内容

18 篇文章 0 订阅

订阅专栏

异常

异常的概述

异常就是不正常的情况

火罐灵尿急  他必须的解决  

程序中的异常：就是在程序的运行中，会出现一些不正常的情况 对于这些情况必须的处理 否则可能导致程序的中断

异常的分类

父类：Throwable
		|---Error 错误  虚拟机内存用完了 无法通过程序去避免解决
		|---Exception 异常 可以通过程序解决 我们可以给出解决方案
			---RuntimeException 运行时异常  编译器是不检查的 未检查异常
			---非RuntimeException  编译器要检查  已检查异常

常见的运行时异常

1.数组下标越界异常
案例：
package cn.baizhi.day17;
public class Demo {
	public static void main(String[] args) {     
		//定义一个数组
		int[] a = new int[5];
		System.out.println(a[5]);	
	}
}

异常信息：
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 5
	at cn.baizhi.day17.Demo.main(Demo.java:12)

=========================================================================================
2.空指针异常
案例：
package cn.baizhi.day17;

public class Demo {
	public static void main(String[] args) {     
		//空指针异常
		int[] a = null;
		System.out.println(a[3]);
		
	}
}

异常信息：
Exception in thread "main" java.lang.NullPointerException
	at cn.baizhi.day17.Demo.main(Demo.java:11)
=========================================================================================
3.类型转换异常
案例：
package cn.baizhi.day17;

public class Demo {
	public static void main(String[] args) {     
		//类型转换异常
		Animal animal = new Dog();
		Cat cat = (Cat)animal;
		
	}
}

class Animal{
	
}
class Dog extends Animal{
	
}
class Cat extends Animal{
	
}
异常信息:
Exception in thread "main" java.lang.ClassCastException: cn.baizhi.day17.Dog cannot be cast to cn.baizhi.day17.Cat
	at cn.baizhi.day17.Demo.main(Demo.java:7)
=========================================================================================
4.数字格式转换异常
案例：
package cn.baizhi.day17;

public class Demo {
	public static void main(String[] args) {     
		String string = "刘洋";
		int a = Integer.parseInt(string);
		System.out.println(a);
	}
}


异常信息:
Exception in thread "main" java.lang.NumberFormatException: For input string: "刘洋"
	at java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)
	at java.lang.Integer.parseInt(Integer.java:492)
	at java.lang.Integer.parseInt(Integer.java:527)
	at cn.baizhi.day17.Demo.main(Demo.java:6)
==================================================================
5.算数除0异常
案例：
package cn.baizhi.day17;

public class Demo {
	public static void main(String[] args) {     
		int a = 3;
		int b = 0;
		System.out.println(a/b);
	}
}


异常信息：
Exception in thread "main" java.lang.ArithmeticException: / by zero
	at cn.baizhi.day17.Demo.main(Demo.java:7)

异常产生的方式

1.自动产生异常
	概念：在程序的运行中，遇到错的代码，就会自动产生异常
	案例：
	package cn.baizhi.day17;

	public class Demo {
		public static void main(String[] args) {     
			int a = 3;
			int b = 0;
			System.out.println(a/b);
		}
}


2.手动产生异常
	我们可以在代码中通过抛出异常的语句手动产生异常
	语法：
	throw  异常的对象；
	案例：
	package cn.baizhi.day17;

	public class Demo {
		public static void main(String[] args) {     
			m1();
		}
	
		public static void m1() {
			System.out.println("方法被调用了");
			//抛出异常的语句
			throw new RuntimeException();
		}
	}

异常父类中的方法

public String getMessage()：能够返回异常的信息
public StackTraceElement[] getStackTrace()：追踪方法的栈异常信息

已检查异常

案例：
package cn.baizhi.day17;

import java.io.EOFException;
import java.io.FileNotFoundException;

public class Demo {
	public static void main(String[] args) {     
		m1();
	}
	
	public static void m1(int a) {
		if (a==1) {
			throw new NullPointerException("空指针异常");
		}
		
		if (a==2) {
			throw new FileNotFoundException("文件找不到异常");
		}
		
		if (a==3) {
			throw new EOFException();
		}
		
		if (a == 4) {
			throw new ClassNotFoundException();
		}
	}
}

异常的解决

消极处理

消极处理：就是将异常一层一层的向上传递 谁调用我 我就抛给谁
案例：
package cn.baizhi.day17;

import java.io.EOFException;
import java.io.FileNotFoundException;

public class Demo {
	public static void main(String[] args) throws FileNotFoundException, EOFException, ClassNotFoundException{     
		m2();
	}
	
	public static void m1(int a) throws FileNotFoundException, EOFException, ClassNotFoundException {
		if (a==1) {
			throw new NullPointerException("空指针异常");
		}
		
		if (a==2) {
			throw new FileNotFoundException("文件找不到异常");
		}
		
		if (a==3) {
			throw new EOFException();
		}
		
		if (a == 4) {
			throw new ClassNotFoundException();
		}
	}
	
	public static void m2() throws FileNotFoundException, EOFException, ClassNotFoundException {
		m1(4);
	}
}

积极处理

语法：
try{
    出现异常的代码；
} catch （异常类   引用）｛
	处理异常代码；
｝

案例：用多态  父类的异常引用 去接收子类的异常对象
package cn.baizhi.day17;

import java.io.EOFException;
import java.io.FileNotFoundException;

public class Demo {
	public static void main(String[] args) { 
		m1(4);
	}
	
	public static void m1(int a)  {
		if (a==1) {
			throw new NullPointerException("空指针异常");
		}
		
		try {
			if (a==2) {
				throw new FileNotFoundException("文件找不到异常");
			}
			
			if (a==3) {
				throw new EOFException();
				//System.out.println("ahjdglksdjl");//不可达语句
			}
			
			if (a == 4) {
				throw new ClassNotFoundException("类找不到异常");
			}
		} catch (Exception e) {//多态  e = new EOFException();
			System.out.println("我老刘已经处理了");
			System.out.println(e.getMessage());
			e.printStackTrace();
			
		}
		
		
	}
	
}

案例：try后可以有多个catch块 用于解决各个异常
package cn.baizhi.day17;

import java.io.EOFException;
import java.io.FileNotFoundException;

public class Demo {
	public static void main(String[] args) { 
		m1(3);
	}
	
	public static void m1(int a)  {
		if (a==1) {
			throw new NullPointerException("空指针异常");
		}
		
		try {
			if (a==2) {
				throw new FileNotFoundException("文件找不到异常");
			}
			
			if (a==3) {
				throw new EOFException();
				//System.out.println("ahjdglksdjl");//不可达语句
			}
			
			if (a == 4) {
				throw new ClassNotFoundException("类找不到异常");
			}
		} 
		catch (FileNotFoundException e) {//多态  e = new EOFException();
			//处理
			System.out.println("FileNotFoundException 异常已经处理");
			
		}
		catch (EOFException e) {
			//处理
			System.out.println("EOFException 已经解决");
		}
		catch (ClassNotFoundException e) {
			System.out.println(e.getMessage());
		}
		
		
	}
	
}

案例：我们可以分步解决异常
package cn.baizhi.day17;

import java.io.EOFException;
import java.io.FileNotFoundException;

public class Demo {
	public static void main(String[] args) { 
		m1(3);
	}
	
	public static void m1(int a)  {
		if (a==1) {
			throw new NullPointerException("空指针异常");
		}
		
		try {
			if (a==2) {
				throw new FileNotFoundException("文件找不到异常");
			}
		} 
		catch (FileNotFoundException e) {//多态  e = new EOFException();
			//处理
			System.out.println("FileNotFoundException 异常已经处理");
			
		}
		
		try{

			if (a==3) {
				throw new EOFException();
				//System.out.println("ahjdglksdjl");//不可达语句
			}
			
		}
		catch (EOFException e) {
			//处理
			System.out.println("EOFException 已经解决");
		}
		
		try{
			if (a == 4) {
				throw new ClassNotFoundException("类找不到异常");
			}
		}
		catch (ClassNotFoundException e) {
			System.out.println(e.getMessage());
		}
		
		
	}
	
}

案例：
当处理异常时，catch块有多个时，代码是从上往下执行 catch块也是从上往下匹配  所以必须先catch子类的异常，再catch父类异常 父类异常必须放在最后  
package cn.baizhi.day17;

import java.io.EOFException;
import java.io.FileNotFoundException;

public class Demo {
	public static void main(String[] args) { 
	}
	
	public static void m1(int a)  {
		if (a==1) {
			throw new NullPointerException("空指针异常");
		}
		try {
			if (a==2) {
				throw new FileNotFoundException("文件找不到异常");
			}
			
			if (a==3) {
				throw new EOFException();
				//System.out.println("ahjdglksdjl");//不可达语句
			}
			
			if (a == 4) {
				throw new ClassNotFoundException("类找不到异常");
			}
		} 
		catch (EOFException e) {
			//处理
			System.out.println("EOFException 已经解决");
		}
		catch (ClassNotFoundException e) {
			System.out.println(e.getMessage());
		}
		
		catch (Exception e) {//多态  e = new EOFException();
			//处理
			System.out.println("FileNotFoundException 异常已经处理");
			
		}
		
		
	}
	
}


案例：try块中可以嵌套 try...catch 结构
package cn.baizhi.day17;

import java.io.EOFException;
import java.io.FileNotFoundException;

public class Demo {
	public static void main(String[] args) { 
		m1(1);
	}
	
	public static void m1(int a)  {
		
		try {
			if (a==1) {
				throw new NullPointerException("空指针异常");
			}
			
			
			//=========================================
			try {
				if (a==2) {
					throw new FileNotFoundException("文件找不到异常");
				}
			} catch (FileNotFoundException e) {
				System.out.println("2异常已经处理");
				e.printStackTrace();
			}
			//=====================================
			
			
			try {
				if (a==3) {
					throw new EOFException();
					//System.out.println("ahjdglksdjl");//不可达语句
				}
				
				if (a == 4) {
					throw new ClassNotFoundException("类找不到异常");
				}
			} catch (Exception e) {
				System.out.println("34异常已经处理");
				e.printStackTrace();
			}
			
			///其他的代码 可能会出现异常
		} 
		catch (Exception e) {//多态  e = new EOFException();
			//处理
			System.out.println("1异常被处理");
			
		}
		
		
	}
	
}

finally语句

银行取钱的过程
try｛
插卡
输密码
输入金额 （可能抛异常）
出钱
｝catch(输入金额大于卡中金额异常 e){
  	syso(你的余额不足  快滚) 
}finally｛
	退卡 //不管取没取出钱 都应该执行
｝

特点：finally语句一定会执行  通常用于关闭资源 
案例：
package cn.baizhi.day17;


public class Demo {
	public static void main(String[] args) {
		int a = m1(2);
		System.out.println(a);
	}
	
	//定义一个方法  接收一个参数
	public static int m1(int a) {
		
		try {
			int s = 6/a;
			
			return s;
		} catch (ArithmeticException e) {
			System.out.println("你个傻X 0不能作为除数");
			
			return 1;
			//e.printStackTrace();
		}finally{
			System.out.println("asdhfgkasdh");
			return 2;
		}
		
	}
	
}

案例：当一个方法中的try块和catch块中由return语句 那么在执行return语句之前会先执行finally语句 再执行return语句
案例：
package cn.baizhi.day17;


public class Demo {
	public static void main(String[] args) {
		int a = m1(2);
		System.out.println(a);
	}
	
	//定义一个方法  接收一个参数
	public static int m1(int a) {
		
		try {
			int s = 6/a;
			return s;
		} catch (ArithmeticException e) {
			System.out.println("你个傻X 0不能作为除数");
			return 1;
			//e.printStackTrace();
		}finally{
			System.out.println("asdhfgkasdh");
			//return 2;
		}
		
	}
	
}

自定异常类

父类一定 Exception  

1.继承Exception 或者是其子类
2.定义无参 和 参数为String的构造

如果继承RuntimeException那么这个异常类为运行时异常 (未检查异常)

案例：
package cn.baizhi.day17;

import java.io.FileNotFoundException;


public class Demo {
	public static void main(String[] args) throws FileNotFoundException, MyException {
		m(2);
	}
	public static void m(int a) throws FileNotFoundException {
		if (a == 1) {
			throw new FileNotFoundException("文件找不到");
		}
		if (a==2) {
			try {
				throw new MyException("尿急");
			} catch (MyException e) {
				System.out.println("去厕所");
			}
		}
	}
}


class MyException extends RuntimeException{
	//无参
	public  MyException() {
		
	}
	//String 有参构造
	public  MyException(String message) {
		super(message);
	}
}

关于方法覆盖中异常的处理

子类的方法覆盖父类的方法时不能抛出比父类方法更宽的异常 只能是父类异常的子类或父类异常 当然也可以不抛在自己的方法内部try...catch解决
代码：
package cn.baizhi.day17;

import java.io.FileNotFoundException;


public class Demo {
	
}


class Animal{
	
	public void eat() throws FileNotFoundException {
		throw new FileNotFoundException();
	}
}

class Dog extends Animal{
	//重写方法
	public void eat() {
		try {
			throw new Exception();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

炳烛之明科技

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java开发必备点16_异常

异常异常的概述异常就是不正常的情况火罐灵尿急他必须的解决程序中的异常：就是在程序的运行中，会出现一些不正常的情况对于这些情况必须的处理否则可能导致程序的中断异常的分类父类：Throwable |---Error 错误虚拟机内存用完了无法通过程序去避免解决 |---Exception 异常可以通过程序解决我们可以给出解决方案 ---RuntimeException 运行时异常编译器是不检查的未检查异常 ---非RuntimeException
复制链接

扫一扫