异常

• 异常体系 Throwable
• • 错误Error
  • 异常Exception
  • • RuntimeException 运行时异常
    • • NullPointerException 空指针异常
    • 除RuntimeException之外的 编译时异常、检查异常
  • throws 和 throw
  • • throws
    • throw
  • try、catch、finally
  • • 运行逻辑
  • Throwable成员方法
  • • getMessage()
    • toString()
    • printStackTrace()
  • 自定义异常
  • 例题
• 时间日期
• • Date
  • SimpleDateFormat
  • LocalDate
  • LocalTime
  • LocalDateTime
  • Clock
  • Duration
  • DateTimeFormatter

创新互联建站长期为成百上千客户提供的网站建设服务，团队从业经验10年，关注不同地域、不同群体，并针对不同对象提供差异化的产品和服务；打造开放共赢平台，与合作伙伴共同营造健康的互联网生态环境。为黔西南州企业提供专业的成都网站建设、成都做网站，黔西南州网站改版等技术服务。拥有10余年丰富建站经验和众多成功案例,为您定制开发。异常体系 Throwable 错误Error

比较严重，依靠代码无法处理，比如内存溢出等。

异常Exception

异常类，程序本身可以处理的问题。异常就是程序出现了不正常的情况。在执行过程中出现的非正常情况，最终导致jvm的非正常停止。

RuntimeException 运行时异常

Java程序在运行时出现的异常。

NullPointerException 空指针异常

空指针异常,又被称为NPE。
为什么会产生npe？原因只有一个，使用了一个null对象的方法。因此定位问题也很简单，注意用了对象.xxx的地方。
解决方式：

1. 条件判断是否为空
2. try catch语句抛出异常

public static void main(String[] args) {Object object = null;
        //抛出处理异常的方式
        //前两者是try-catch抛出异常，更推荐这一种
        //
        try {System.out.println(object.toString());
        } catch (NullPointerException e){e.printStackTrace();
            System.out.println("发生空值异常");
        }
        //
        try {System.out.println(object.toString());
        } catch (NullPointerException e){throw e;
        }
        //条件判断是否为空
        if (object == null) {System.out.println("obje不能为空");
        } else {System.out.println(object.toString());
        }

除RuntimeException之外的 编译时异常、检查异常

编译期必须处理的，否则程序不能通过编译。如果在发生运行时异常之前先发生了编译时异常，那么运行时异常不会抛出。

throws 和 throw throws

throws，抛出一个异常类，用在方法声明之后，表示这个方法在运行过程中可能会产生一个异常，但是方法内部不知道该怎么处理，于是将这个异常抛出，让使用该方法的人去处理，如果一直不处理那么会一直抛出交给jvm处理。可以写很多个异常类在后面，取决于该方法可能会出现多少个异常。

public void show() throws NullPointerException,IllegalArgumentException,ArrayIndexOutOfBoundsException{throw new NullPointerException("空指针异常");
    }
    public void ExceptionDemo() throws NullPointerException,IllegalArgumentException,ArrayIndexOutOfBoundsException,IOException{}

throw

throw 用在方法体内，跟的是异常对象名,表示手动抛出异常对象，由方法体内的语句处理。

public static void main(String[] args) {try {FileWriter fileWriter = new FileWriter("x.abc");
        } catch (IOException e){throw new RuntimeException(e);
        }
    }

try、catch、finally

1. 三者只有三种组合形式：try-catch、try-catch-finally、try-finally
2. 使用的好处时运行出现异常后将其抛出，程序继续运行不受影响
3. 捕获到异常后怎么处理，完全取决于业务逻辑要求

运行逻辑

catch允许同时写很多个，当try里面的代码块出现异常时会根据捕获到的异常的类型到catch里面一个一个对应看与哪一个catch相符合，执行相应的catch，而finally里面的代码块一般情况下表示必须要执行的，且是最后执行。如果有return，那么finally里面的代码是在retur之前执行。如果出现的异常在catch里面找不到，那么这个异常会被继续往上抛，最终会抛给jvm处理，程序停止执行。
如果太多异常不想写那么catch，可以直接捕获所有异常的父类Exception，但是不推荐，无法准确得知出现的是何种异常。不过所有可能的异常被捕获了还有一些未知异常可以使用这个方法。

public class FinallyLogic {public static void main(String[] args) {int bb = getAge();
        System.out.println(bb);
    }

    private static int a = 0;

    public static int getAge() {try {//            System.out.println("221");
            return aa();
        } catch (Exception e) {} finally {a = 1;
            System.out.println(a + "------------");
            return a;
        }
    }

    public static int aa() {a = 2;
        System.out.println(a);
        return a;
    }
}

执行结果为：

Throwable成员方法 getMessage()

返回此 throwable 的详细消息字符串。

toString()

返回此可抛出的简短描述。

printStackTrace()

把异常的错误信息输出在控制台。

try {inputStream = new FileInputStream("aaa");
//            inputStream.close();
//            System.exit(0);
        } catch (FileNotFoundException e) {System.out.println(e.toString() + "++++++++++++");
            System.out.println(e.getMessage()  + "-----------------");
            e.printStackTrace();
        } finally {try {if (inputStream != null){inputStream.close();
                }
            } catch (IOException e) {e.printStackTrace();
            }
        }

自定义异常

自定义异常，可以认为是Java给的异常满足不了使用需求了我们自己定义的异常。
具体格式参考下面代码，必须要继承自另一个已有的异常类。

public class AgeoutOfBoundsException extends RuntimeException {public AgeoutOfBoundsException() {}

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

由上可见，自定义异常必须继承自Java自带的一个异常类，且要有无参和有参两个构造方法。具体如何使用详见下面例题。

例题

import java.util.Scanner;

public class StudengPrint {public static void main(String[] args) throws AgeoutOfBoundsException {Student student = new Student();
        while (true) {Scanner scanner = new Scanner(System.in);
            try {System.out.println("请输入年龄：");
                student.setAge(scanner.nextInt());
            } catch (AgeoutOfBoundsException e) {System.out.println("你输入的年龄错误，请重新输入");
            }
            System.out.println("请输入姓名");
            student.setName(scanner.next());
            System.out.println("是否继续输入？y/n");
            Exit(scanner.next());
        }

    }

    public static void Exit(String choose) {if (choose.equals("y")) {} else {System.out.println("谢谢您的使用");
            System.exit(0);
        }
    }

}

class Student {private String name;
    private int age;

    public void setName(String name) {this.name = name;
    }

    public String getName() {return name;
    }

    public void setAge(int age) {if (age >= 18 && age<= 25) {this.age = age;
        } else {throw new AgeoutOfBoundsException("你输入的年龄错误，请重新输入");
        }
    }

    public int getAge() {return age;
    }

    public Student() {this.name = "student";
        this.age = 18;
    }

    public Student(String name, int age) {this.name = name;
        this.age = age;
    }
}
public class AgeoutOfBoundsException extends RuntimeException {public AgeoutOfBoundsException() {}

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

运行结果

注意：能用逻辑解决的就尽量不要使用异常，不推荐将异常当作if-else这样的判断来用。

时间日期

计算机中的时间原点：1970年1月1日。

Date

时间类，现在不常用了，里面很多方法都已经过时废弃。
Date有两个构造方法，区别如下：
new Date();程序运行的当前时间
new Date(参数);根据括号里面的毫秒数确定时间

public class MyDate {public static void main(String[] args) {Long start = System.currentTimeMillis();//1970年1月1日到当前时间的毫秒
        System.out.println(start);
        Date date = new Date();//程序运行的当前时间
        Date date1 = new Date(start-24*60*60*1000);//根据括号里面的毫秒数确定时间
        System.out.println(date);
        System.out.println(date1);
        System.out.println(date1.toLocaleString());
    }
}

SimpleDateFormat

这是对Date时间类的一个封装，也就是时间的格式化。
其中，parse方法用来判断时间格式是否是规定的格式。

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class MySimpleDateFormat {public static void main(String[] args) {Date date = new Date();
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss ssss");
        //此处规定的时间格式是年-月-日 时：分：秒 毫秒
        System.out.println(dateFormat.format(date));
        try {date = dateFormat.parse("2022-08-09 14:32:48 0039");//不符合规定，抛出异常,符合正常执行
        } catch (ParseException e) {System.out.println("时间格式错误，我们需要的格式是：yyyy-MM-dd HH:mm:ss ssss");
        }
    }
}

LocalDate

当前本地的日期，只有日期没有构造方法，只有静态方法创建对象,now()是当前的日期。
成员方法atTime()的两个参数表示时和分，其返回值是LocalDateTime。

import java.time.LocalDate;
import java.time.LocalDateTime;

public class MyLocalDate {public static void main(String[] args) {LocalDate localDate = LocalDate.now();
        LocalDateTime localDateTime = localDate.atTime(17, 06);
        System.out.println(localDate);
        System.out.println(localDateTime);
    }
}

LocalTime

只有时间，没有日期，与LocalDate相似，没有构造方法只有静态方法初始化。其能精确到毫秒。

import java.time.LocalTime;

public class MyLocalTime {public static void main(String[] args) {LocalTime localTime = LocalTime.now();
        System.out.println(localTime);
    }
}

LocalDateTime

综合了LocalDate和LocalTime，日期时间全部都有。不过还是没有构造方法只有静态方法。

import java.time.LocalDateTime;

public class MyLocalDateTime {public static void main(String[] args) {LocalDateTime localDateTime = LocalDateTime.now();
        System.out.println(localDateTime);
    }
}

Clock

时钟对象，有构造方法，但是是受保护的，protected方法，只能子类使用。一般将其与LocalDateTime一起用可以根据时区拿到对应的时间。

import java.time.Clock;
import java.time.LocalDateTime;

public class MyClock {public static void main(String[] args) {Clock clock = Clock.systemUTC();
        //Clock.systemUTC() 获取UTC时间当前时刻的时钟
        System.out.println(clock);
        LocalDateTime localDateTime = LocalDateTime.now(clock);
        System.out.println(clock.instant());
        //返回由时钟定义的当前的瞬时点
        System.out.println(localDateTime);
    }
}

systemUTC()是Clock的一个方法，用于获取UTC时间当前时刻的时钟。所以此处输出的结果不是本地东八区的时间，要获取到本地时区的，那么与systemDefaultZone()有关，该方法使用默认时区返回当前时刻，所以返回的就是本地的时钟。如下使用即可获取本地时间。

public static void main(String[] args) {Clock clock = Clock.systemDefaultZone();
        System.out.println(clock);
        LocalDateTime localDateTime = LocalDateTime.now(clock);
        System.out.println(clock.instant());
        System.out.println(localDateTime);
    }

返回结果如下，可见已经是本地的时间了。

第一排结果是当前Clock使用的时区，第二排是UTC时间，第三排是本地时间

Duration

Duration可以用来比较两个时间之间的差（可以得到天、小时、分、秒等），包括了获取差值的天数、小时数、分钟、毫秒等多个方法。同样，没有构造方法有静态方法，此处使用between(初始时间,与初始时间对比的时间)。其意义是获取两个时间的差值，再使用其他方法返回具体的天数等。

public class MyDuration {public static void main(String[] args) {LocalDateTime today = LocalDateTime.now();
        System.out.println(today);
        LocalDateTime startDate = LocalDateTime.of(2000,1,1,8,0,0);
        //设置起始时间为2000年1月1日8点0分0秒
        System.out.println(startDate);

        // 现在时间减去起始时间
        Duration duration = Duration.between(startDate,today);
        // 两个时间差的天数
        System.out.println(duration.toDays() + "天");
        // 两个时间差的小时数
        System.out.println(duration.toHours() + "小时");
        // 两个时间差的分钟数
        System.out.println(duration.toMinutes() + "分钟");
        // 两个时间差的秒数
        System.out.println(duration.getSeconds() + "秒");
        // 两个时间差的毫秒数
        System.out.println(duration.toMillis() + "毫秒");
        // 两个时间差的纳秒数
        System.out.println(duration.toNanos() + "纳秒");
        // 下面这个方法是计算秒与纳秒，最后返回秒，其他of开头的与之相似，可以是负数
        System.out.println(Duration.ofSeconds(3, -3601));
        // 下面这个方法是以指定的秒数返回此持续时间的副本，也就是通过传入秒数来构造一个Duration副本，返回值是这个副本的持续时间加上这个指定的秒数，其他with开头的与之相似
        System.out.println(duration.withSeconds(3));
    }
}

DateTimeFormatter

和SimpleDateFormat差不多，也是对时间的一个格式化包装，主要用在Local一系。
parse(CharSequence text, DateTimeFormatter formatter)，使用特定的格式化 LocalDateTime从文本字符串获取 LocalDateTime的实例。
format(DateTimeFormatter formatter)，使用指定的格式化程序格式化此日期时间。

public static void main(String[] args) {String dateTimeStr= "2022-12-14 11:11:11";
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        LocalDateTime localDateTime=LocalDateTime.parse(dateTimeStr,formatter);
        System.out.println(localDateTime);
        String format = localDateTime.format(formatter);
        System.out.println(format);
    }

你是否还在寻找稳定的海外服务器提供商？创新互联www.cdcxhl.cn海外机房具备T级流量清洗系统配攻击溯源，准确流量调度确保服务器高可用性，企业级服务器适合批量采购，新人活动首月15元起，快前往官网查看详情吧

分享题目：Java——异常和时间日期-创新互联
链接分享：http://azwzsj.com/article/dccgee.html