package cn.china;
/**
* 异常：在运行时期发生的不正常情况。
* 问题很多，意味着描述的类也很多，
* 将其共性进行向上抽取，形成异常体系。
* 最终问题就分成两大类：
* throwable:无论是Error，还是异常，都是问题，就应该可以抛出，让调用者知道并处理。
* 该体系的特点就在于throwable及其所有子类都具有可抛性。
* 如何体现可抛性？
* 其实是通过两个关键字体现的，throws,throw;凡是可以被这两个关键字操作的类和对象都具有可抛性。
* 1、一般不可处理的，Error
* 特点：是由JVM抛出的严重性问题，已经影响到我们程序的执行；这种问题发生一般不针对性处理，直接修改程序
* 2、可以处理的，Exception
* 特点：子类的后缀名都是用其父类名作为后缀，阅读性很强。
*
* 异常分类：
* 1、编译时被检测异常：只要是Exception和其子类都是，除了RunTimeException和其子类
* 这种问题一旦出现，希望在编译时就进行检测，让这种问题有对应的处理方式。
* 这样的问题都可以针对性的处理
* 2、编译时不检测异常（运行时异常）：RunTimeException和其子类。
* 这样的问题的发生，无法让功能继续，运算无法进行，更多是因为调用的原因导致的或者引发了内部状态的改变导致的。
* 这种问题一般不处理，直接编译通过，在运行时，让调用者调用时的程序强制停止，让调用者对代码进行调整。
*
* throw 和 throws区别？
* throws 使用在函数上 抛出的是异常类，可以抛出多个可以用逗号隔开
* throw 使用在函数内 抛出的是异常对象*/
class FuShuIndexException extends Exception//所以这里可以继承RunTimeException,就不需要声明或者捕捉异常，编译不会失败
{
public FuShuIndexException(String meg) {
super(meg);
// TODO Auto-generated constructor stub
}
}
class D{
public int method(int arr[],int index)throws FuShuIndexException
{
if(arr==null)
throw new NullPointerException("数组的引用不能为空！");
if(index>=arr.length)
throw new ArrayIndexOutOfBoundsException("数组越界了！"+index);
if(index<0)//准备用负数角标异常来表示，但是这种异常在java中并没有定义过。按照java异常的创建思想，将负数角标进行自定义描述，并封装成对象
throw new FuShuIndexException("数组的角标不能为负数"+index);
return arr[index];
}
}
public class Demo {
public static void main(String[] args) throws FuShuIndexException
{
int[]arr=new int[3];
D d=new D();
int num= d.method(arr, -30);
}
}
package cn.china;
/**异常处理的捕捉形式
* 具体格式：
* try
* {需要被检测异常的代码}
* catch(异常类 变量) //该变量用于接收发生异常的对象
* {处理异常的代码}
* finally
* {一定会被执行的代码}
*
*
* 异常处理原则：
* 1、函数内部如果抛出需要检测的异常，那么函数上必须要声明，否则必须在函数内必须要用trycatch捕捉，否则编译失败。
* 2、如果调用到了声明异常的函数，要么trycatch要么throws,否则编译失败。
* 3、什么时候catch,什么时候throws呢？
* 功能内部可以解决，用catch;
* 解决不了用throws，告诉调用者，调用者解决；
* 4、一个功能如果抛出多个异常，那么调用时必须由对应多个catch进行针对性处理。
* 内部有几个要检测的异常，就抛几个异常，抛出几个，就catch几个；*/
class FuShuIndexException extends Exception//所以这里可以继承RunTimeException,就不需要声明或者捕捉异常，编译不会失败
{
public FuShuIndexException(String meg) {
super(meg);
}
}
class C{
public int method(int arr[],int index)throws FuShuIndexException
{
if(arr==null)
throw new NullPointerException("数组的引用不能为空！");
if(index>=arr.length)
throw new ArrayIndexOutOfBoundsException("数组越界了！"+index);
if(index<0)//准备用负数角标异常来表示，但是这种异常在java中并没有定义过。按照java异常的创建思想，将负数角标进行自定义描述，并封装成对象
throw new FuShuIndexException("数组的角标不能为负数"+index);
return arr[index];
}
}
public class Demo1 {
public static void main(String[] args) {
int[]arr=new int[3];
C c=new C();
try
{
int num= c.method(arr, -30);
System.out.println("num"+num);//num是局部变量 所以这两句话要放在同一个代码块
}
catch(NullPointerException e){//多catch格式
e.printStackTrace();
}
catch(ArrayIndexOutOfBoundsException e){
e.printStackTrace();
}
catch(FuShuIndexException e)
{
e.printStackTrace();//JVM默认的异常处理机制就是调用异常对象的这个方法。
System.out.println("Message"+e.getMessage());
System.out.println("String"+e.toString());
System.out.println("负数角标异常！");
}
catch(Exception e){//父类需要放在最下面，不然编译失败，因为Exception跟所有异常都匹配，
e.printStackTrace();
}
System.out.println("over!");
}
}
package cn.china;
/**try catch finally 组合特点
* 1、 try catch finally
* 2、try catch(多个当没有必要资源需要释放时，可以不用定义finally)
* 3、 try finally
* 例：void show()throws Exception //因为没有catch所以必须声明异常
* {
* try{
* //开启资源
* throw new Exception
* }
* finally{
* //关闭资源
* }
* }*/
class E{
public int method(int index)
{
int[]arr=new int[3];
if(index>=arr.length)
throw new ArrayIndexOutOfBoundsException();
return arr[index];
}
}
public class Demo2 {
public static void main(String[] args) {
E e=new E();
try{int num=e.method(3);
System.out.println(num);
}catch(ArrayIndexOutOfBoundsException c)
{
System.out.println(c.toString());
return;
//System.exit(0); 退出JVM只有这种情况不会执行finally语句；
}
finally {//一定会被执行的语句,主要用于关闭或者释放资源
System.out.println("finally");
}
System.out.println("over!");
}
}
package cn.china;
import java.time.format.TextStyle;
/**
* 毕老师用电脑上课，
* 分析其中问题：
* 电脑蓝屏，冒烟*/
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 Computer{
private int state=0;
public void run()throws LanPingException,MaoYanException
{
if(state==1)
throw new LanPingException("蓝屏啦");
if(state==2)
throw new MaoYanException("电脑冒烟了");
System.out.println("电脑运行");
}
public void reset(){
state=0;
System.out.println("电脑重启了");
}
}
class Teacher{
private String name;
private Computer comp;
Teacher(String name){
this.name=name;
comp=new Computer();
}
public void prelect()throws NoPlanException
{
try
{
comp.run();
System.out.println("讲课");
}catch(LanPingException e){
System.out.println(e.toString());
comp.reset();
prelect();
}catch(MaoYanException e){
System.out.println(e.toString());
test();
throw new NoPlanException("课时无法进行"+e.getMessage());
//可以对电脑进行维修
//throw e;
}
}
public void test(){
System.out.println("大家练习");
}
}
public class Demo3 {
public static void main(String[] args) {
Teacher teacher=new Teacher("毕老师");
try
{
teacher.prelect();
}
catch(NoPlanException e)
{
System.out.println(e.toString()+"......");
System.out.println("换人");
}
}
}
/**
* class NoAddException extends Exception{}
* void addData(Data d)throws NoAddException
* {
* 链接数据库
* try{
* 添加数据库，出现异常 SQLException();
* }catch(SQLException e)
* {
* //处理代码
* throw new NoAddException();
* }finally
* {
*
* 关闭数据库
* }
* }*/
package cn.china;
/**异常的注意事项
* 1、子类在覆盖父类方法时如果父类的方法抛出异常，那么子类的方法只能破案出父类的异常，或者该异常的子类
* 2、如果父类抛出多个异常，那么子类子还能抛出父类异常的子集
*
* 简单说：子类覆盖父类，只能抛出父类的异常，或者子集；如果父类没有抛出异常，那么子类覆盖时绝对不能抛出异常，但是可以用try;*/
class A extends Exception
{
}
class B extends A
{}
class C extends Exception
{}
class Fu{
void show()throws A{}
}
class Zi extends Fu{
void show()throws B{}//只能抛出A或者B
}
class Test{
void method(Fu f){
try{
f.show();
}catch(A a){}
}
}
public class Demo4 {
public static void main(String[] args) {
Test t=new Test();
t.method(new Zi());
}
}
时间： 2025-01-04 02:39:28