异常与枚举小结

最新推荐文章于 2022-07-08 12:49:06 发布

iefegend

最新推荐文章于 2022-07-08 12:49:06 发布

阅读量431

点赞数

分类专栏： java学习交流文章标签： exception enum java 黑马程序员面向对象

本文链接：https://blog.csdn.net/h1328523782/article/details/38757201

版权

java学习交流专栏收录该内容

12 篇文章 0 订阅

订阅专栏

一、异常

1、异常

异常：是指程序在运行时出现的不正常情况。其实就是程序中出现的问题。这个问题按照面向对象思想进行描述，并封装成了对象。因为问题的产生有产生的原因、有问题的名称、有问题的描述等多个属性信息存在。当出现多属性信息最方便的方式就是将这些信息进行封装。异常就是java按照面向对象的思想将问题进行对象封装。这样就方便于操作问题以及处理问题。

出现的问题有很多种，比如角标越界，空指针等都是。就对这些问题进行分类。而且这些问题都有共性内容比如：每一个问题都有名称，同时还有问题描述的信息，问题出现的位置，所以可以不断的向上抽取。形成了异常体系。

异常的体系 Throwable

Error

通常指JVM出现重大问题如：运行的类不存在或者内存溢出等。

不需要编写针对代码对其处理，程序无法处理。

Exception

在运行时运行出现的一些情况，可以通过try，catch，finally处理；

异常处理两种方式：

1)、捕获异常：try catch 直接处理可能出现的异常！

2)、声明异常：throws 声明告诉调用者可能的异常，暴露问题，调用者自己处理！

2、异常处理格式

异常处理的5个关键字

try ，catch，

finally

throw,，throws

异常处理格式

try{

//可能出异常的代码

} catch(异常类对象){

//处理该异常类型的语句

}

[finally] {

//一定会执行的代码

//catch块使用System.exit(1);除外

}

备注：当try语句块出现异常，程序会自动跳到catch语句块去找匹配的异常类型，并执行异常处理语句，finally语句块是异常的统一出口。

3、多异常处理

声明异常时尽可能声明具体异常类型，方便更好的处理；

方法声明几个异常就对应有几个catch块；

若多个catch块中的异常出现继承关系，父类异常catch块放在最后；

在catch语句块使用Exception类作为异常类型时：

所有子类实例都可以使用父类接收(向上转型)，即所有的异常对象都可以使用Exception接收；

注：在java处理多异常时捕获小范围的异常必须放在大范围异常之前。

//java7 - 同时捕获多个异常类型
//Java7之前：
try {
         int a = Integer.parseInt("1");
         int b = Integer.parseInt("0");
         int c = a / b;
         System.out.println(c);
} catch (NumberFormatException e)
{
   e.printStackTrace();
} catch(ArithmeticException e)
{
         e.printStackTrace();
}
 //Java7：将多个异常写到了同一个catch代码块
try {
Integer a = Integer.parseInt("1");
Integer b = Integer.parseInt("0");
 Integer c = a / b;
 System.out.println(c);
} catch (NumberFormatException
         | ArithmeticException  e ) {
          e.printStackTrace();
}

4、异常的分类

异常分类：

编译时被检查异常； ---> Checked异常

在程序中必须要对异常进行处理；

编译时不被检测的异常； ---> Runtime异常

可以不使用try...catch处理，但一旦出现异常就将由JVM处理。

1)、异常的分类之Runtime异常

RuntimeException(运行时异常)是指因设计或实现方式不当而导致的问题；

说白了,就是程序员造成的，程序员小心谨慎是完全可以避免的异常。比如，事先判断对象是否为null就可以避免NullPointerException异常，事先检查除数不为0就可以避免ArithmeticException异常；

特点：

这种异常Java编译器不会检查它，也就说程序中出现这类异常的时候，即使不处理也没有问题，但是一旦出现异常，程序将异常终止，若采用异常处理,则会被相应的程序执行处理。

2)、异常的分类之Checked异常

除了RuntimeException以及子类，其他的Exception及其子类都是受检查异常，我们也可以称为非RuntimeException异常。

特点：

Java编译器会检查它，也就说程序中一旦出现这类异常，要么是没有try-catch语句捕获,或throws语句没有声明抛出它，编译就不会通过，也就说这种异常,程序要求必须处理。

5、声明异常（throws）

在可能出现异常的方法上声明抛出可能出现异常的类型：

声明的时候尽可能声明具体的异常，方便更好的处理。

当前方法不知道如何处理这种异常，可将该异常交给上一级调用者来处理(非RuntimeException类型的异常)。

方法一旦使用throws声明抛出方法内可能出现的异常类型，该方法就可以不再过问该异常了；

一个方法调用另一个使用throws声明抛出的方法，自己要么try...catch ，要么也throws；

格式：

public 返回值类型方法名(参数列表...)

throws异常类A,异常类B... {

}

6、抛出异常throw

自行抛出一个异常对象，抛出异常类的对象；

若throw抛出的是Runtime异常：

程序可以显示使用try...catch来捕获并处理，也可以不管，直接交给方法调用者处理；

若throw抛出Checked异常：

要么放在try里自己处理，要么放在一个throws声明的方法里面，交给调用者处理。

eg：
         public static void main(String[] args) {
                   try {
                         method1(1);
                   } catch (Exception e) { e.printStackTrace(); }
                   method2(2);
         }
         public static void method1(int a) throws Exception{
                   if(a >0) { throw new Exception("fn1 -- a值不合法"); }
         }
         public static void method2(int a) {
                   if(a >0) { throw new RuntimeException("a值不合法"); }
         }

throws & throw

throws用于在方法上声明该方法不需要处理的异常类型。

throw用于抛出具体异常类的对象。

throws与throw的区别：

thorws用在方法上，后面跟异常类名,可以是多个异常类。

throw用在方法内，后面跟异常对象,只能是一个。

7、finally

异常的统一出口：

不管try块程序是否异常，也不管哪个catch执行，finally块总会执行。

try语句块或会执行的catch语句块使用了JVM系统退出语句例外；//System.exit(1);

try块必须和 catch块或和finally同在，不能单独存在，二者必须出现一个。

不要在finally中使用return或throw语句，否则将会导致try、catch中的return或throw失效。

finally代码块只在一种情况下不执行：System.exit(0)；

eg：
package com.demo.exception;
public class ExceptionDemo1 {
         public static void main(String[] args) {
                   try{
                            System.out.println(17/0);
                   }catch(Exception e){
                            //e.printStackTrace();
                            System.out.println("程序错误，请修正！");
                   }finally{
                            System.out.println("这是finally代码块！");
                   }
         }
}
输出：
程序错误，请修正！
这是finally代码块！

8、throw和catch同时使用

当异常出现在当前方法中,程序只对异常进行部分处理，还有一些处理需要在方法的调用者中才能处理完成，此时还应该再次抛出异常，这样就可以让方法的调用者也能捕获到异常；

eg：
public static void buy(String price) throws Exception {
         try {
                   if(price != null)
                            Double.parseDouble(price);
         } catch (Exception e) {
                   e.printStackTrace();
                   throw new Exception("价格不能只能是数字组成");
         }
}
public static void main(String[] args)  {
         try {
                   buy(null);
         } catch (Exception e) {
                   System.out.println(e.getMessage());
         }
}

二、枚举

1)、使用enum声明,默认直接继承了java.lang.Enum类，而不是Object类；

2)、枚举类的对象是固定的,实例个数有限,不可以再new( ),枚举对象后可以跟()。

3)、枚举元素必须位于枚举类体中的最开始部分,枚举元素后要有分号与其他成员分隔。

4)、枚举类的构造方法的权限修饰符默认是private；

5)、一旦枚举对象后面加上{},那么该对象实际是枚举匿名内部类对象;

6)、所有枚举类都提供一个静态的values()方法(返回该枚举类所有对象组成的数组),便于遍历所有枚举对象；

7)、所有枚举类都提供一个静态的valueOf(String name)方法,返回枚举类中对象名等于 name的对象。

eg：
public enum Color{
         RED(), GREEN(){}, BLUE{};
}
package reviewDemo;
//枚举
enum Color{
         Green,Blue,Yellow;
        @Override
         public String toString() {
                   String ret = super.toString();
                   switch (this) {
                   case Green:
                            ret = "绿色";
                            break;
                   case Blue:
                            ret = "蓝色";
                            break;
                   case Yellow:
                            ret = "黄色";
                            break;
                   default:
                            break;

                  }
                   return ret;
         }
         
}
 
class Personp{
         Color c = Color.Blue;
         void show(){
                   System.out.println(c);
         }
}
 
public class Demo18 {
         public static void main(String[] args) {
                   Color []color = Color.values();
                   for (Color c : color) {
                            System.out.println(c);
                   }
                   new Personp().show();
         }
}
输出：绿色蓝色黄色蓝色
枚举类覆写接口抽象方法的两种方式：
在枚举类中实现接口的抽象方法；
在枚举匿名内部类中实现接口的抽象方法；
 interface I{
    void show();
}
enum Color implements I{
    RED(){
         public void show(){
        }
    }, GREEN{
         public void show(){
        }
    }, BLUE{
         public void show(){
        }
    };
}
enum Color implements I{
    RED(), GREEN, BLUE;
    public void show() {
    }
}

iefegend

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
异常与枚举小结

一、异常1、异常异常：是指程序在运行时出现的不正常情况。其实就是程序中出现的问题。这个问题按照面向对象思想进行描述，并封装成了对象。因为问题的产生有产生的原因、有问题的名称、有问题的描述等多个属性信息存在。当出现多属性信息最方便的方式就是将这些信息进行封装。异常就是java按照面向对象的思想将问题进行对象封装。这样就方便于操作问题以及处理问题。出现的问题有很多种，比如角标越界，空指针等...
复制链接

扫一扫