1-14 枚举和异常

最新推荐文章于 2025-02-22 19:49:58 发布
原创 最新推荐文章于 2025-02-22 19:49:58 发布 · 260 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java

回顾作业

package com.qfedu.StringHomeWork;

import java.awt.*;
import java.util.Arrays;
import java.util.Scanner;

public class HomeWork {
    public static void main(String[] args) {
        /*
        从控制台录入一个字符串，如果这个字符串以大写字母开头，将该字符串转成全小写；如果这个字符串以小写字母开头，将该字符串转成全大写
        */
        //First();
        /*
         去除字符串中所有的空格。例如 a b c d e  f --> abcdef
        */
        //Second();
        /*
        将一个字符串进行反转。将字符串中指定部分进行反转 例如 abcdefg --> abfedcg
        */
       // thrid();
        /*
        将电话号中间4位替换成XXXX 例如13842383838-->138XXXX3838
        */
       // fourth();
        /*
        已知字符串:"this is a test of java"
        执行以下操作:
        1.统计出字符串中s出现的次数
        2.取出字符串中"test"
        3.将字符串转换成一个字符数组
        4.将字符串中每个单词的第一个字母变成大写,输出到控制台
        5.将字符串是此案倒叙输出 "java of test a is this"
        */
       // fifth();
        /*
        输入一个时间，输出它的下一秒时间(字符串版本)
        例如
        输入:20:39:40
        输出20:39:41
        20:39:59
        20:40:00
        20:59:59
        21:00:00
        23:59:59
        00:00:00
        */
        //Sxith();
        /*
         "华为"公司去年的营业额是：1798798099079798098
        格式化后的金额信息是：1,798,798,099,079,798,098
        */
       //Seventh();
    }

    public static void Seventh() {
        String money = "179879809907979809840895285084230580925802758943275";
        StringBuilder bs = new StringBuilder(money);
        for(int i = bs.length()-3; i> 0;i-=3){
            bs.insert(i,',');
        }
        System.out.println(bs);
    }

    public  static void Sxith() {
        Scanner input = new  Scanner(System.in);
        System.out.println("请输入时间：");
        String time = input.next();
        //切分换算
        String[] split = time.split(":");//{时，分，秒}
        //将字符串转换数字
        int h = new  Integer(split[0]);
        int m = Integer.parseInt(split[1]);
        int s = new  Integer(split[2]);
        //逻辑计算
        s++;
        if( s == 60){
            s = 0;
            m++;
            if(m == 60){
                m =0;
                h++;
                if(h == 24){
                    h = 0;
                }
            }
        }
        System.out.println(String.format("%02d",h)+":"+String.format("%02d",m)+":"+String.format("%02d",s));
    }

    public static void fifth() {
        String  str = "this is a test of java";
        //1.统计出字符串中s出现的次数
        int count  = 0 ;
        for (int i = 0; i <str.length() ; i++) {
            if(str.charAt(i) == 's'){
                count++;
            }
        }
        System.out.println("s在字符串中出现的次数："+count);
        //2.取出字符串中"test"
        int index = str.indexOf("test"); //可以获取字符串中t所出现从位置
        String substring = str.substring(index, (index + "test".length()));
        System.out.println("截取test："+substring);

        // 3.将字符串转换成一个字符数组
        char[] chars = str.toCharArray();
        System.out.println("字符串转换为字符数组："+ Arrays.toString(chars));
        // 4.将字符串中每个单词的第一个字母变成大写,输出到控制台 ---> This Is A Test Of Java
        //先切分字符串
        String[] s = str.split(" "); //单词字符串数组
        //拼接字符串使用
        StringBuilder bs = new StringBuilder();
        char[] buf ;
        for(String  ss : s){ //ss 会取出每一个单词
            buf  = ss.toCharArray(); //{t,h,i,s}
            buf[0] = (char)(buf[0] - 32);
            for(int i = 0;i<buf.length;i++){
                bs.append(buf[i]);
            }
            bs.append(" ");
        }
        System.out.println("单词的首字母大写："+bs.toString());
        // 5.将字符串是此案倒叙输出 "java of test a is this"
        String[] s1 = str.split(" ");
        for(int  i = 0 ;i< s1.length/2;i++){
            String tmp = s1[i];
            s1[i] = s1[s1.length-1-i];
            s1[s1.length-1-i] = tmp;
        }
        //静态join方法 --> 以某个符号来连接数组字符串
        //第一个参数是 符号 第二个参数是 数组
        String  newStr = String.join(" ",s1);
        System.out.println(newStr);

    }

    public  static void fourth() {
        String  number = "13842383838";
        //1. 第一种
        char[] chars = number.toCharArray();
        for(int i = 0 ;i<chars.length;i++){
            if(i >=3 && i<=6){
                chars[i] = '*';
            }
        }
        String  str = new String(chars);
        System.out.println(str);

        //replaceAll 方法 替换   根据正则表达式进行替换
        // 第一个参数是正则表达式 ， 第二个参数是替换方法  --》 主要满足这个需求【正则】都会被进行替换
        //$数字 --》 代表的当前组  【即一个小括号就是一个组】
        String  str1 = number.replaceAll("(\\d{3})\\d{4}(\\d{4})","$1****$2");
        System.out.println(str1);
    }

    public static void thrid() {
        Scanner input = new  Scanner(System.in);
        System.out.println("请输入字符串：");
        String str = input.next();
        System.out.println("请输开始的位置：");
        int begin = input.nextInt();
        System.out.println("请输入结束的位置：");
        int end = input.nextInt();
        //截取要翻转的位置
        String substring = str.substring(begin, end);
        //字符串构建器中存储着截取字符串
        StringBuilder bs = new StringBuilder(substring);
        //翻转截取字符串
        String newStr = bs.reverse().toString();
        String replace = str.replace(substring, newStr);
        System.out.println(replace);

    }

    public static void Second() {
        String str = " a b c d e  f ";
        StringBuilder bs = new StringBuilder();
        for (int i = 0 ;i<str.length();i++){
            //无论是 String 还是 StringBuffer和StringBuilder  他们底层都是字符数组 所以支持下标
             if(str.charAt(i) != ' '){
                 bs.append(str.charAt(i));
             }
        }
        //字符串构建器 可以使用 toString 转换我 String字符串  --》 new String
        System.out.println(bs.toString());
    }
    public static void First(){
        //1.控制台上获取数据
        Scanner input = new Scanner(System.in);
        System.out.println("请输入字符串：");
        //next方法 在控制台上获取字符串
        /*
        next方法 获取结束输入符号   回车、空格、tab 只要任意一个出现 next 就会做为结束
         */
       // nextLine方法 在控制台上获取字符串
        /*
         nextLine 方法  获取回车作为结束符号
         */
        String  str = input.next();
        //只要是大写 就转换为 全小写
        if(str.charAt(0) >= 'A' && str.charAt(0)<='Z'){
            System.out.println(str.toLowerCase());
            //只要是小写 就转换为 全大写
        }else if(str.charAt(0)>='a' && str.charAt(0)<='z'){
            System.out.println(str.toUpperCase());
        }else{
          System.out.println("不合法无法转化");
          // throw  new  RuntimeException("不合法的转换");
        }

    }
}

枚举

枚举是一种数据类型【可以通过反编译软件看到枚举真正的存储】，枚举存储的是一个静态常量

主要作用是用来描述无法使用变量描述的事务

需求： 定义一个星期数【从星期一 ~ 星期日】

不使用枚举
    int week = 1;
如果这样写，语义不明，变量容易被修改，如果对当前值进行修改，没有一个统一的存储路径【局部还是全局的】

从JDK1.5开始系统提供了一个定义，这个定义可以在内部定义常量，使用的时候用即可以使用名字触发常量的调用，这个定义–》【枚举 Enum】

枚举的语法：

访问权限修饰符  enum  枚举名字{
	常量名1，常量名2 ...
}
ps：有多个常量使用逗号隔开

语法：

package com.qfedu.Enum;

/**
 * 枚举定义
 */
public enum  WeekDay {
    //星期名
    MONDAY,TUESDAY,WEDNESDAY,THURSDAY,FRIDAY,SATURDAY,SUNDAY
}
/*


package com.qfedu.Enum;


public final class WeekDay extends Enum
{

	public static final WeekDay MONDAY;
	public static final WeekDay TUESDAY;
	public static final WeekDay WEDNESDAY;
	public static final WeekDay THURSDAY;
	public static final WeekDay FRIDAY;
	public static final WeekDay SATURDAY;
	public static final WeekDay SUNDAY;
	private static final WeekDay $VALUES[];

	public static WeekDay[] values()
	{
		return (WeekDay[])$VALUES.clone();
	}

	public static WeekDay valueOf(String name)
	{
		return (WeekDay)Enum.valueOf(com/qfedu/Enum/WeekDay, name);
	}

	private WeekDay(String s, int i)
	{
		super(s, i);
	}

	static
	{
		MONDAY = new WeekDay("MONDAY", 0);
		TUESDAY = new WeekDay("TUESDAY", 1);
		WEDNESDAY = new WeekDay("WEDNESDAY", 2);
		THURSDAY = new WeekDay("THURSDAY", 3);
		FRIDAY = new WeekDay("FRIDAY", 4);
		SATURDAY = new WeekDay("SATURDAY", 5);
		SUNDAY = new WeekDay("SUNDAY", 6);
		$VALUES = (new WeekDay[] {
			MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
		});
	}
}

 */

说明：

1.枚举是一个特殊的类，通过反编译软件可以发现枚举在底层就是一个类并默认继承一个Enum类才成为枚举

2.Enum这个类是所有枚举的基类【父类】，所有创建的枚举都要继承于这类，才会形成枚举，这个类不允许外界手动继承

3.因为枚举在底层是一个类，所以在枚举定义的常量都是在类中以【public static final】 修饰

​ 这个类中提供静态方法以便使用，只有用过反编译才会查看到枚举有一个隐藏的静态方法

values方法 --》 获取枚举数组–》 这个数组存储着所有的枚举值

4.枚举是不能new ，因为在反编译中可以发现枚举构造方法是私有的，所以不能创建对象

​ 所以枚举的使用 【枚举名.定义的常量】

综上所述：枚举的出现就是为了解决，Java中对某些现实中定义的语义加以明确

​ 枚举是一个特殊的类型【引用类型】，特殊在于枚举只能使用自身定义的常量，其余任何值都不能使用

如果枚举需要对这些特殊类型进行判断，可以使用switch

switch这个分支能接受的数据 int，char，String 和 enum

需求：使用枚举定义春夏秋冬，并随机获取季节

package com.qfedu.Enum;

public enum Season {
    //枚举是使用汉字合理的位置
    春,夏,秋,冬
}
package com.qfedu.Enum;

import java.util.Random;

public class EnumTest {
    public static void main(String[] args) {
        Season s = getSeason();
        //判断当枚举中值
        switch (s){
            case 春:
                System.out.println("春天来了");
                break;
            case 夏:
                System.out.println("夏天来了");
                break;
            case 秋:
                System.out.println("秋天来了");
                break;
            case 冬:
                System.out.println("冬天来了");
                break;
        }


    }
    public static Season getSeason(){
        int random = new Random().nextInt(4)+1;
        switch (random){
            case 1:
                //获取枚举中值
                return Season.春;
            case 2:
                return Season.夏;
            case 3:
                return Season.秋;
            case 4:
                return Season.冬;
            default:
                //枚举是一个引用类型，所以要么就接收自身要么就接收null
                return null;
        }
    }
}

ps：只从Java7开始，swich中支持字符串之后，枚举的作用在逐渐减少，枚举底层是一个类，所以可以代替部分类的操作，着也是现阶段没有的作用所在。

异常

什么是异常？

程序中出现了问题，这个问题会影响到程序无法正常执行，并提示出一些信息，这样的方式就是【异常】

PS：无Bug不代码 ，【bug虐我千百遍，我待bug如初恋】

Java中对程序Bug提示的方式有两种

一种【Exception异常】，程序猿可以处理 ， 一种【Error错误】，程序猿无法处理

Java中就提供了一个异常图谱，所有异常和错误都继承于Throwable类【所有异常和错误的超级父类】

请添加图片描述

说明：

Throwable是所有错误和异常超级父类

Error【错误】：一般指的是JVM出现了不可修复的问题，此时会出现异常退出JVM的情况

例如： 栈溢出或堆溢出，JVM直接崩溃，这些错误是程序猿无法处理【我们要避免】

出现的表示【XXXXXXXXXXXError】，以Error做为结尾就证明是错误

package com.qfedu.Throwable.Error;
/*
 JVM错误
 StackOverflowError  栈溢出
 */
public class ErrorDemo {
    public static void main(String[] args) {
        new ErrorDemo().show();

    }
    public  int show(){
         return show();//递归 死递归，程序只有Error才会退出
    }
}

Exception【异常】 主要分为两种

1.编译时异常【Exception】 编写代码时出现提示错误**【红色的浪线或Unhandled exception】**，必须立即处理，不然会报异常，若强行运行，结果就是程序直接崩溃

2.运行是异常【RuntimeException】在编写代码的阶段是无法察觉【编译阶段不会做任何提示】，只有当程序运行的时候，会出现崩溃异常。

PS：以任何方式获取到异常，对异常任何处理都是对异常的补救

常见异常

异常类含义原因
NullPointerException空指针异常引用了一个地址为null的对象，并调用对象本身的方法或属性
ArrayIndexOutOfBoundsException数组下标越界异常下标超出了范围【出现小于0或大于等于当前数组长度】
StringIndexOutOfBoundsException字符串下标越界异常字符串下标超出了范围【出现小于0或大于等于当前字符串长度】
NumberFormatException对数据进行转换异常例如：new Integer(“123a”)
ClassCastException强制类型转换异常父类转子类类型不匹配
ArithmeticException数学异常除数为0

Java中对异常处理

对异常抓取【捕捉|捕获】

1.使用try-catch语句进行抓取

语法：
    try{
       可以能会出现异常的代码 
    }catch(可能出现异常类型 e){
        //e 是异常类型对象，可以在catch语句块中国进行使用， e对象可以获取一些异常信息
      处理异常【打印信息，继续抛出异常，记录日志】 
    }

演示：

package com.qfedu.Throwable.Exception;
//抓取异常演示
public class TryCatchDemo {
    public static void main(String[] args) {
        //1.不处理异常出现的不能后续的代码的问题
//        System.out.println("begin。。。。。。。。。。。");
//        int x = 9;
//        int y = 0;
//        //出现异常会直接影响后续的代码的执行【所以异常必须处理】，会中断程序
//        //中断程序是程序猿必须处理的问题
//        //此时出现的这个异常就是 【运行时异常RuntimeException】
//        int result = x/y;
//        System.out.println(result);
//        System.out.println("end。。。。。。。。。。。。");

        //2.处理异常
        System.out.println("begin。。。。。。。。。。。");
        int x = 9;
        int y = 1;
        int result = 0 ;
        /*
         抓取异常目的，就是对程序猿进行提示，如果是系统提示，程序会执行崩溃无法继续执行
         而我们自己抓取异常时，程序可以提示信息继续向后执行，保证正常执行流程
         第一友好的提示程序猿出现错误， 第二个保证程序可以继续正常执行
         提示错误之后，程序猿进行代码修改，修改try位置的代码

        若程序出现异常，就走catch语句块
        若程序没有异常，catch语句块就不会执行

         */
       try { //尝试抓取出现的异常
             result = x / y;
             //catch里面的小括号，出现什么异常就 抓取什么异常类型
        }catch(ArithmeticException e){
           //对当前异常进行补救措施 ， 可以打印信息或打印异常栈信息，或写入日志等等
           //1.做提示 getMessage()方法可以获取当前异常出现的信息提示
           System.out.println(e.getMessage());
           //2.自定义提示
           System.out.println("出现了异常，除数为0......");
           //3.直接打印异常跟踪栈信息【和崩溃异常打印是一样】
           e.printStackTrace();
       }
        System.out.println(result);
        System.out.println("end。。。。。。。。。。。。");
    }
}

2.try-catch抓取多个异常

语法：
    try{
       可以能会出现异常的代码 
    }catch(可能出现异常类型 e){
        //e 是异常类型对象，可以在catch语句块中国进行使用， e对象可以获取一些异常信息
      处理异常【打印信息，继续抛出异常，记录日志】 
    }catch(可能出现异常类型 e){
        //e 是异常类型对象，可以在catch语句块中国进行使用， e对象可以获取一些异常信息
      处理异常【打印信息，继续抛出异常，记录日志】
    }

ps：理论上catch语句是可以多个，有多少个异常就可以使用多少个catch

演示

package com.qfedu.Throwable.Exception;
/*
 try-catch抓取多异常
 */
public class TryMoreCatchDemo {
    public static void main(String[] args) {
//        int x = 9;
//        int y = 1;
//        int[] arr = new int[1];
//        int  result = 0;
//        try{
//            result = x / y ;
//            arr[0] = 10;
//            System.out.println(arr[1]);
//            System.out.println(result);
//            //如果异常之间没有【 父子关系】 哪个异常在前哪个异常在后都是可以
//            //如果存在【父子关系】 子类异常一定要在父类异常之前
//            /*
//              代码中有多个异常建议可以写多个catch语句进行抓取匹配
//               抓取的父类异常一定要在 所有子类异常的后面 --》 【也就是放到最后一个catch语句中】
//             */
//        }catch (ArithmeticException e){
//            System.out.println("除数为0 不能计算");
//        }catch (ArrayIndexOutOfBoundsException e){
//            System.out.println("下标越界了");
//        }
//        System.out.println("正常执行完毕");
//        
        //在Java7之后 ，Java对多个抓取 提供一个新的语法 叫做平行抓取  就是在catch语句中使用 |
                int x = 9;
        int y = 1;
        int[] arr = new int[1];
        int  result = 0;
        try{
            result = x / y ;
            arr[0] = 10;
            System.out.println(arr[1]);
            System.out.println(result);
            //如果异常之间没有【 父子关系】 哪个异常在前哪个异常在后都是可以
            //如果存在【父子关系】 子类异常一定要在父类异常之前
            /*
              代码中有多个异常建议可以写多个catch语句进行抓取匹配
               抓取的父类异常一定要在 所有子类异常的后面 --》 【也就是放到最后一个catch语句中】
             */
        }catch (ArithmeticException | ArrayIndexOutOfBoundsException e){
            System.out.println("除数为0不能计算或数组下标越界异常");
        }
        System.out.println("正常执行完毕");

    }
}

PS： 实际开发中如果遇到 多个异常需要抓取， 异常万能抓取方式 catch后面 抓取的异常写**【Exception】**

​ 可以解决任何异常抓取，Java官方是不推荐直接抓取Exception，出现哪个异常就就抓取哪个。

3.try-catch-finally抓取异常释放

finally语句块：特点无论是否发生异常，finally一定执行

finally语句块作用:

finally语句块一般是写在catch语句块的后面，主要的作用就是用来释放资源【流的关闭，网络连接，线程池的释放，数据库连接释放】

   try{
       可以能会出现异常的代码 
    }catch(可能出现异常类型 e){
        //e 是异常类型对象，可以在catch语句块中国进行使用， e对象可以获取一些异常信息
      处理异常【打印信息，继续抛出异常，记录日志】 
    }finally{
       资源释放
    }

演示：

package com.qfedu.Throwable.Exception;

public class TryCatchFinallyDemo{
    public static void main(String[] args) {
          int x = 9;
          int y = 0;
          try{
              int result = x/y;
              System.out.println(result);
          }catch (ArithmeticException e){
              System.out.println("除数为0不能计算...");
              //极特殊情况， 直接关闭JVM
              System.exit(1);
          }finally {
              System.out.println("finally语句块被执行了.....");
          }
    }
}

Finally语句块的面试

package com.qfedu.Throwable.Exception;

public class TryCatchFinallyDemo2 {
    public static void main(String[] args) {
        System.out.println(Result1()); //结果
        System.out.println(Result2());
    }
    public static int Result1(){
        int x = 9;
        int y = 3;
        int result =0;
        try {
            result = x / y;  // 9 / 0  --> 出一个算数异常
            return  result;
        } catch (ArithmeticException e) {  // 这里会进行捕捉异常
             return  Integer.MAX_VALUE; //最大值会返回
        } finally { //finally语句块一定执行 它和 return是统一个级别
            result ++; // 3+1
            System.out.println("finally语句块中result的值是："+result); //结果？
        }

    }

    public static  int Result2(){
        try{
            return  1;
        }finally {
            //只要finally中有return语句， 语句永远执行finally中return ，一定要避免这样使用
            return 100;
        }
    }

}

总结： finally语句块停止执行只会出现System.exit方法退出JVM，就算有return依旧会执行并且如果finally中有return必然执行finally中

4.try-finally

    try{
       可以能会出现异常的代码 
    }finally {
       资源释放
    }

总结： try–catch语句块一般是使用在容易出现异常位置，一定要避免全局抓取，编译时异常建议进行抓取处理，运行是异常如果能预知这个位置会出现异常，就建议抓取，如果不能确定，出现异常之后在进行抓取

final、finally、finalize三个关键字的区别

1、final修饰符（关键字）

被final修饰的类，就意味着不能再派生出新的子类，不能作为父类而被子类继承。因此一个类不能既被abstract声明，又被final声明。将变量或方法声明为final，可以保证他们在使用的过程中不被修改。

2、finally是在异常处理时提供finally块来执行任何清除操作。

不管有没有异常被抛出、捕获，finally块都会被执行。try块中的内容是在无异常时执行到结束。catch块中的内容，是在try块内容发生catch所声明的异常时，跳转到catch块中执行。

3、finalize是方法名。

java技术允许使用finalize方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。这个方法是由垃圾收集器在确定这个对象没有被引用时对这个对象调用的。它是在object类中定义的，因此所有的类都继承了它。子类覆盖finalize方法以整理系统资源或者被执行其他清理工作。

对异常抛出

因为try-catch代码块比较长而且繁琐，所以一共一种新处理异常方式，将异常抛出处理，抛出异常处理有两种方式一种是在方法声明时进行抛出操作，另外一种是在方法的内部进行抛出操作，这两个操作也是对异常处理，这个处理可以让代码看起来更加简洁，虽然代码简洁了，但是不能自定提示信息，抛出异常的重点就是main方法，也就是说所有异常的抛出最终接受的都mian方法，所以建议在main方法中将所有异常都处理，main方法中是不应还抛出异常，否则程序猿就时区了作用。

PS：抓取异常和抛出异常都是对异常的处理，无论是那种都可以

【throw】含义是抛出异常

主要用于在方法体的内部，出现了一些无法处理的情况可以使用这样方式进行信息提示，如果这个异常不适合在这个方法处理，可以使用throw将异常继续向上抛出

语法:

throw new  异常类型("异常信息提示");

PS: 这个throw相当于是方法中的一个 return，方法碰到throw也会停止

【throws】含义是抛出异常

主要写在方法声明的位置即形参后面，将方法出现异常信息抛出给调用方法者，由调用方法者来处理这个异常，而非在方法的内部异常处理

PS： 书写throws的时机，这个方法中会出现异常，但是这个异常不适合方法本身处理，就建议将异常抛出处理

​ throws可以抛出任何类型的异常，但是如果抛出的是Exception【编译时类型异常】，调用者就必须处理这个异常，否则会报错，但是如果抛出的是RuntimeException【运行时异常】，调用和可以无视

抛出异常演示

package com.qfedu.Throwable.Exception;

import java.net.InetAddress;
import java.util.Objects;

/**
 * 异常抛出
 */
public class ThrowDemo {
    public static void main(String[] args)throws  NumberFormatException {
        String str = "123a";
        try {
            int number = getNumber(str);
            System.out.println(number);
        }catch (NumberFormatException e){
            System.out.println(e.getMessage());
        }
//       Object o = getNumber2("3");
//        o.toString();

        //调用这个方法就会获取到抛出异常，两种处理方式，
        // 第一种建议 在这里可以进行一次try-cacth
        // 第二种建议 继续抛出 ，最终出现在main方法是建议处理掉所有异常，如果异常过多抛出，最终接受和这个异常就是JVM虚拟机
        getNumber3(str);

    }
    public static int getNumber(String str){
        //原始做法：可以try-catch处理异常
        try {
            return new Integer(str).intValue();
        }catch(NumberFormatException e){
           //提示异常信息【抛出异常】
            //这个throw 就相当是一个 return
            //此时你抛出的是一个异常对象，外部如果要获取这个异常对象，可以在外部调用方法的位置
            //执行try-catch抓取
            throw new NumberFormatException("输入的字符串不和法："+str);
        }
    }
    public static Object getNumber2(String str){
        if(str.equals(1)){
            return Integer.MAX_VALUE;
        }else if(str.equals(2)){
            return Integer.MIN_VALUE;
        }else{
           throw new  RuntimeException("输入的数据没有合适的值!");
        }

    }

    //将方法中异常抛给调用者，此时就可以不使用 try-catch来处理异常
    public static int getNumber3(String str)throws NumberFormatException{
        return  new Integer(str).intValue();
    }
}

总结：

1.对异常处理一个共两种方式，一种try-catch，另外一种中就是throws

PS：个人建议尽量是用try-catch，如果其他人都抛你也抛

2.throws只能在方法的声明的位置写不能再放体的内部中属性，如果方法体的内部使用throw 创建了一个编译时异常，若不在方法体内部处理【不使用try-catch】，那么就必须配合使用throws将这个异常抛给调用者

public static int getNumber4(String str)throws Exception{
         throw new Exception("dhfkajfladkjfaljfl");
  }

自定义异常

Java中系统中提供了很多异常，但是这些异常并不能满足所有情况，判断腿的异常，身高异常，体中异常？

当出现一些定制异常的时候，系统异常就不能满足需求，此时我们可以创建自己的异常

自定义异常分为两个种类

1.运行时自定义异常，创建一个自定义异常类，这个类继承于RuntimeException【程序运行时就提示有异常】

2.编译时自定义异常，创建一个自定义异常类，这个类继承于Exception【编写代码时就提示有异常】

无论是继承哪一个，都需要仿照父类生成自己的构造方法即可

自定义异常

package com.qfedu.Throwable.Exception;
//自定义异常
public class TuiExecption extends RuntimeException {
    //仿照父类生成自己的构造方法即可

    public TuiExecption() {
    }

    public TuiExecption(String message) {
        super(message);
    }

    public TuiExecption(String message, Throwable cause) {
        super(message, cause);
    }

    public TuiExecption(Throwable cause) {
        super(cause);
    }

    public TuiExecption(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
        super(message, cause, enableSuppression, writableStackTrace);
    }
}

异常链

异常链的存在主要是为了对已经存在的原有异常进行包装，让异常与异常之间形成一个调用关系，并且在外部输出提示信息的时候是一个连续的异常打印，这个就是异常链

请添加图片描述

请添加图片描述

枚举解决自定义异常
杨春建的博客
04-17 1863
原文地址：http://blog.youkuaiyun.com/sunhuwh/article/details/43545329 自定义异常： [java] view plain copy public interface ExceptionEnums {            public int getCode();            public String g
springboot全局异常处理枚举加业务层
weixin_45863786的博客
10-15 417
*** @description: 服务类接口*//*** 错误码* @return*//*** 错误描述* @return*//*** @description: 异常处理枚举类*/// 数据操作错误定义SUCCESS("2000", "成功!"),BODY_NOT_MATCH("4000","请求的数据格式不符!"),//SIGNATURE_NOT_MATCH("4001","请求的数字签名不匹配!"),NOT_FOUND("4004", "未找到该资源。
C# 枚举常用扩展方法(枚举帮助类)
Syspan
10-24 3872
更新时间：2019-10-30 枚举常用扩展方法(枚举帮助类)，目前个人用到的方法整理如下： using System; using System.Collections.Generic; using System.ComponentModel; using System.Linq; using System.Reflection; using System.Text; using S...
枚举和异常
域清风
08-16 352
1.枚举 1.特有属性 默认继承类，所以只能实现接口 枚举类构造方法默认为私有方法。 枚举可以有属性，但是属性需要在构造方法中赋值 public class Demo4 { public static void main(String[] args) { Sex sex = Sex.woman; //name为sex的名字，woman ordinal为位...
Python数据结构与算法（1）---枚举类型enum
李元静
05-05 5107
目录前言创建枚举迭代枚举比较枚举enum.IntEnum唯一枚举值代码中创建枚举 前言 之所以博主思考再三，开设一个数据结构的基础冷门课程。是因为目前大多数数据结构的书籍都使用的是C/C++，无疑增加了学习的门槛。 而python语言相对来说，更容易入门掌握，通过python学习数据结构与算法，对于初学者似乎更加的友好。 本篇，首先介绍的是枚举类型。在python库中，提供了枚举模块enum。通过该模块，我们可以定义程序员容易理解的字面量整数与字符串。 创建枚举 话不多说，我们先来创建一个简单的枚举类：星期
MybatisPlus-扩展功能-枚举处理器
最新发布
m0_57047579的博客
02-22 567
那如果说你想让它以value返回，也就是1和2返回，或者是以desc这个中文返回，那么你就需要告诉我们程序，我们这个程序的数据往前端返回由Spring MVC处理，Spring MVC 底层它在处理JSON的时候用到一个Jackson包，Jackson它提供一些注解用来标记这个枚举里面的值到底把谁进行返回。在Mybatis里有一个叫TypeHandler的类型处理器，我们常见的PO当中的这些成员变量的数据类型，它都有对应的处理器，因此它就能自动实现这些Java数据类型与数据库类型的相互转换。
实验报告1-Spring Boot自定义异常处理-资料.rar
09-18
为了更好地组织和管理异常信息，开发者通常会采用枚举类来定义错误码和错误信息，确保错误码的一致性和可维护性。 在提供的项目文件中，pom依赖文件列出了项目所需的所有依赖库，其中应包括Spring Boot的起步依赖...
Java学习笔记 --- 枚举类
乌云的博客
10-20 1218
1、枚举对应英文（enumeration，简写 enum） 2、枚举是一组常量的集合 3、可以这样理解：枚举属于一种特殊的类，里面只包含一组有限的特定的对象
【BUG 记录】MyBatis-Plus 处理枚举字段和 JSON 字段
JAVA开发区的博客
02-26 1934
MyBatis-Plus 处理枚举字段和JSON字段
枚举与异常
Ab_999的博客
07-31 482
枚举 枚举的基本定义和使用 枚举的定义 定义枚举类型， 需要使用到关键字 enum 。 枚举的名字是一个标识符， 遵循大驼峰命名法。 public enum Gender { // 将这个枚举对象所有可能取到的值, 都列出来 // 枚举中的元素, 也是标识符, 遵循大驼峰命名法 Male, Female } public enum Month { Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov, Dec } public
15.枚举与异常
松松的博客
08-08 317
枚举是一个引用类型，枚举就是一个规定了取值范围的变量类型。 枚举变量不能使用其他的数据，只能使用枚举中常量赋值。提高程序安全性 注意事项 枚举中的成员是此枚举的取值范围; 所有的值之间使用逗号分隔，最后一个值后可以加分号也可以不加分号; 在枚举中可以声明方法，但是必须在所有的取值之后声明，而且最后一个值后必须使用分号隔开. 1 枚举的本质：其实就是终止类，并继承Enum抽象类。 2 枚举中的...
枚举类型与自定义异常
Chengqb的博客
06-27 2448
枚举类型与自定义异常目录1、定义响应码与响应消息枚举型2、自定义异常（1）服务异常（2）业务异常3、自定义异常使用 注： 个人认为一个项目中，最好有2个自定义异常；一个是 服务 异常，一个是 业务 异常 1、定义响应码与响应消息枚举型 package com.xxx.xxx; /** * @Auther: Chengqb * @Date: 2019/6/27 8:40 */ ...
枚举、泛型、异常
qq_43647383的博客
06-17 216
目录一、枚举1.概述2.枚举的定义3.枚举中声明属性和方法4.内置方法二、泛型<>1.泛型概述2.泛型的定义与使用1）定义和使用含有泛型的类2）自定义泛型3.含有泛型的方法4.含有泛型的接口5.泛型通配符6.通配符高级使用----受限泛型 一、枚举 1.概述 在JDK1.5中引入了一个新的类型——枚举。可以简单地理解枚举就是一种特殊的java类，在这个特殊的类当中定义几个静态变量，每个变量都是这个类的实例。通过关键字enum实现，自动继承自Enum类（枚举类）。 枚举（enum），是指一个经过
异常处理,枚举，泛型
weixin_34270865的博客
04-25 137
Java异常处理： 5个关键字： try（尝试）、catch（捕获）、 finally（最终的）、throw（抛出）、throws 使用方法： finally ：一般写的是资源释放代码，无论是否发生异常代码总能执行。 try{}catch(异常类型){} try{}catch(异常类型){} finally{} public class TestThrows { //除...
枚举 异常信息
Connie1451的博客
09-13 877
/** * 使用枚举类型来封装异常码和异常信息 * @author zhength * @version 1.0.0 * @email connie1451@163.com * @date 2018/9/12 16:33 * @since 1.8 */ public enum ErrorCodeMsg { //RPC层调用错误码 OK(2010...
枚举、异常
weixin_30595035的博客
08-17 158
1.访问权限修饰符 enum 枚举名{ //静态常量 常量A,常量B,常量C; }2.枚举只能给枚举对象赋值 枚举名 对象 = 枚举名.常量A; 对象存储的就是枚举值3.switch...case形式 switch(对象|枚举名.常量A){ //枚举中定义的常量 case 常量A: 执行语句; break; ...
自定义枚举类，异常类，处理异常
tianqi11的博客
05-22 249
package com.seckill.seckill.vo; import lombok.AllArgsConstructor; import lombok.Getter; import lombok.ToString; @Getter @AllArgsConstructor @ToString public enum respBeanEnum { ERROR(500,"服务端异常"), SUCCESS(200,"success") ; private final Inte
自定义异常及枚举类使用
weixin_30385925的博客
07-22 604
自定义异常 理解error、RuntimeException（运行时，虚拟机报的错）和非RuntimeException(编译时，编译器找出的错） 1.java中异常均继承自Throwable,其有两个重要的直接子类error与exception. 2.java错误error，大部分是由虚拟机爆出来的错误，是程序无法处理的错误,如OutOfMemoryError...
基于枚举和断言的异常处理机制实现
然而，其特别之处在于并非采用传统的try-catch或直接抛出Exception的方式，而是引入了**枚举类作为异常码和提示信息的载体**，并通过自定义的断言工具方法进行条件判断和异常抛出。这种设计思想广泛应用于现代企业级...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值