华杉研发九学习日记17 正则表达式 异常

华杉研发九学习日记17

一，正则表达式 ^ $

作用：

• 测试字符串内的模式(匹配)
  • 例如，可以测试输入字符串，以查看字符串内是否出现电话号码模式或信用卡号码模式。这称为数据验证.
• 替换文本（替换》
  • 可以使用正则表达式来识别文档中的特定文本，完全删除该文本或者用其他文本替换它.
• 基于模式匹配丛字符串中提取子字符串（提取》。
  • 可以查找文档内或轮入域内特定的文本。

//  [a-z]   [A-Z]   [a-zA-Z]    [0-9]
//  {n}     {n,}最少n次    {n,m}最少n最多m
String s="abcDdwadawddgFDFSFGSEGSEEGEg";    //  账号  字母组成长度四位
String reg="^[a-zA-Z]{4,}$";    //  ^  开始   $  结尾
System.out.println(s.matches(reg));
 //      \d 匹配数字  {}不写默认为{1}
        String pwd="123456";
        String regpwd="^\\d{6}$";
        System.out.println(pwd.matches(regpwd));

        //  验证手机号
        String phone = "15575942805";
        String regphone="^(13|15|17|18|19)[0-9]{9}$";
        if(phone.matches(regphone)){
            System.out.println("是移动号码");
        }

        //  验证日期    2024-7-24
//        String regdate = "^\\d{4}-\\d{1,2}-\\d{1,2}$";
        String regdate = "^\\d{4}(-\\d{1,2}){1,2}$";
        String date="2024-07-24";
        System.out.println(date.matches(regdate));

        //  验证汉字
        String name = "李四";
        String regname="^[\\u4e00-\\u9fa5]{2,}$";
        System.out.println(name.matches(regname));
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

正则替换：

//  正则替换
String st1="d小314124s孤a4241243鸡6dADad";
st1=st1.replaceAll("[^\\u4e00-\\u9fa5]","");
System.out.println(st1);    //  小孤鸡
1
2
3
4

二，异常

所谓异常：就出现了出乎意料的事情。

在代码里：所谓异常也是程序在编写或者运行过程中出现了出乎意料的事情。

异常：就是在java中的代码的运行期或编译器出现的例外情况。

异常的影响:
1.一旦代码出现异常，则会直接在该异常处终止整个java虚拟机

​ 2.一旦java虚拟机终止，则其后的业务代码不在执行

​ 3.—旦出现异常，则整个程序直接终止运行

三，异常的分类

2.1 Error

Error是 Throwable的子类，用于指示程序不应该试图捕获的严重问题。

Java程序通常不捕获错误。错误一般发生在严重故障时，它们在Java程序处理的范畴之外。错误例如:栈溢出错误,硬盘空间不足,“虚拟机损坏等等!

Error是系统级别的错误，需要进行硬件处理，代码不可以处理，我们就简单了解即可。

//  Error级别错误之  死递归  栈溢出
public static void method(){
        int a=11;
        int b=22;
        method();
}
public static void main(String[] args) {
    method();
}
1
2
3
4
5
6
7
8
9

2.2 Exception（异常）

Exception是程序中的异常,即由于代码缺陷(bug)引起的问题.这类问题需要程序员处理.

Exception是代码级别的异常，在程序中如果不处理，会造成程序的不可运行，需要我们处理.

Exception异常主要分为两类

• 运行期异常
• 非运行期异常(即编译期异常)

代码阶段

关联图：

2.2.1 运行时异常

运行期异常就是在代码的运行代码的过程中出现的例外情况。

RunntimeException及其子类都是运行时异常。

运行期异常是Java中的可能出现的例外情况，可以处理也可以不处理，最好处理。

2.2.2 编译时异常

编译期异常就是Java代码在编译的过程中出现的例外情况。

编译期的异常不是Java的中语法错误。

如果不解决编译期的异常，则ava源文件不能编译成字节码文件，不可运行。

编译期的异常必须处理，如果不处理，则IDEA中的Java代码报错。

Exception中除了RunntimeException及子类之外的其他异常都是编译期异常。

四，异常处理

异常有两种解决方案:
1.用try…catch代码块来处理异常。

​ 2.抛出(throws)异常，把异常抛给调用当前方法的代码层去处理异常

4.1 try…catch处理异常

捕捉并处理异常

格式：

try{
    可能出现异常的代码块;
}catch(异常类){
    处理异常
}catch(异常类){
    处理异常
}
	...
  finally{
      无论是否有异常都执行的代码块;
  }
1
2
3
4
5
6
7
8
9
10
11

注意

​ 1.多个catch的异常类从上到下定义时必须类是从小到大的

​ 2.如果出现异常，则会执行第一个满足于该异常的异常类，而不是最精准的 异常类

​ 3.多个catch最多只能执行一个catch异常类

try{        //  可以处理该代码块出现的异常情况
    String s = null;
    System.out.println(s.length());
    int a = 23;
    int b = 0;
    System.out.println(a / b);  //  一旦出现异常，后面的语句不执行
//  一般使用 try--catch 就是用来处理异常的
//  一般建议紧跟多个catch  但是只执行一个catch
}catch (NullPointerException e){    //  当捕捉到该异常时，处理的语句
    System.out.println("NullPointerException");
}catch (ArithmeticException e){
    System.out.println("ArithmeticException");
}catch(ClassCastException e){
    System.out.println("ClassCastException");
} catch(RuntimeException e){
    System.out.println("运行时异常");
}catch (Exception e){
    System.out.println("其他异常");
}catch(Throwable e){
    System.out.println("异常");
}finally{
    System.out.println("不管有没有异常都会执行的语句");
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

4.2 finally

注意：

​ 在try…catch带有方法的返回值时，执行顺序

1、不管有没有出现异常，finally块中代码都会执行;

2、当try和catch中有return时，finally仍然会执行;

3、如果在finally之前遇到了return语句（此时并不会返回结果，而是先把要返回的值保存起来，不管finally中的代码怎么样，返回的值都return时刻的值);

4、finally中最好不要包含return，否则程序会提前退出，返回值不是try或catch中保存的返回值

try {
        return a + b;
    }catch(Exception e) {
        System.out.println("进入异常");
        return 10;
    }finally {
        System.out.println("进入finally");
    }
}
public static void main(String[] args) {
    System.out.println(sum(10,20));
}
1
2
3
4
5
6
7
8
9
10
11
12

4.2 throws 处理异常

throws关键字来抛出异常声明。throws 关键字放在方法名的尾部(即方法体左大括号的前面).

throws是捕捉异常但是不处理异常，告诉调用者需要去处理异常。

如果一直通过throws抛出异常声明,如果真的出现了异常,异常最后会被虚拟机捕获到,虚拟机的处理方式是中断程序的执行.

throws其实就是为了快速解决不想处理异常。也能通过编译期的处理方式。

try…catch和throws的处理异常方式的区别:

​ 1.try…catch捕捉并处理异常。不需要二次处理

​ 2.throws捕捉异常但不处理，需要进行二次处理

public static void main(String[] args) throws ParseException {
    ttry();
    tthrows();
}
	//	try..catch
public static void ttry() {
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
    String str = "2024-07-24";
    Date date = null;
    try {
        date = sdf.parse(str);
    } catch (ParseException e) {
        throw new RuntimeException(e);
    }
    System.out.println(date);
}
	//	throws
public static void tthrows() throws ParseException {
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
    String str = "2024-07-24";
    Date date= sdf.parse(str);
    System.out.println(date);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

五，throw关键字

throw是在java程序应用中可以用来产生异常情况。

throw可以用来抛出编译时异常类和运行时异常类。

即throw可以抛出Throwable体系里所有的异常。

//  请输入你的年龄 --  判断合法性
Scanner sc = new Scanner(System.in);
System.out.println("请输入你的年龄：");
int a = sc.nextInt();
if(a<0||a>150){			//	抛出异常进行提示
    throw new RuntimeException("你的年龄不合法");
}
System.out.println("年龄："+a);
1
2
3
4
5
6
7
8

六，自定义异常

自定义异常就是根据我们的项目的需求来自己设定异常类，如果出现异常，则直接报出我们自己定义的异常来处理。

自定义异常的分类：

• 继承RuntimeException类
• 继承Excption类

6.1 继承RuntimeException类

步骤：

1.定义一个异常类。继承RunntimeException类

2.定义一个有参的和无参的构造器，无参的调用有参的，有参的调用父类有参的构造器

3.在使用时，根据条件来使用throw抛出自定义的异常类

//自定义异常 --  年龄不合法

public class AgeNoException extends RuntimeException {
    public AgeNoException() {
        this("年龄不合法");
    }
    public AgeNoException(String message) {
        super(message);
    }
}
1
2
3
4
5
6
7
8
9
10

6.2 继承Exception类

继承Exception类，相当于编译时异常，需要进行处理（throw或try…catch）

其他同上