首页 \ 问答 \ Java中抛出异常的顺序(Order of throws exceptions in Java)

Java中抛出异常的顺序(Order of throws exceptions in Java)

 我正在编写用于将文件读入Java的代码。  
 我有一个主要的方法，抛出三个异常。 我想知道如果我在public static void main(String[] args)的同一行中切换写异常的顺序会有什么影响。  
public class SwitchTester {

    private static Scanner pathInput;

    public static void main(String[] args) throws IOException, NoSuchElementException, IllegalStateException{
 
 我使用main方法中的代码。 我使用的异常顺序是此代码中的IOException，NoSuchElementException，IllegalStateException。 在主线保持相同的顺序是否重要？ 保持在主线上的投掷是否重要？  
    try{         
        pathInput = new Scanner(path);
    }catch(IOException ioException){
        System.err.println("Error opening file. Terminating.");
        System.exit(1);
    }

    System.out.printf("%-10s%-15s%-15s%10s%n", "Port", "Destination",
             "Source", "Data-type");

    //readRecords
    try{
        while(pathInput.hasNext()){ //while there is more to read, display record contents
            System.out.printf("%-10s%-15s%-15s%10s%n", pathInput.next(), 
                    pathInput.next(), pathInput.next(), pathInput.next());
        }
     }catch(NoSuchElementException elementException){
         System.err.println("File improperly formed. Terminating.");
     }catch(IllegalStateException stateException){
         System.err.println("Error reading from file. Terminating.");
     }
 
 我很感激你的回答！ 谢谢！ 

I am writing code for reading files into Java. 
I have a main method that throws three Exceptions. I am wondering what would the impact would be if I switched the order of writing the exceptions in the same line of public static void main(String[] args). 
public class SwitchTester {

    private static Scanner pathInput;

    public static void main(String[] args) throws IOException, NoSuchElementException, IllegalStateException{
 
I use the code inside the main method. The order of exceptions I use is IOException, NoSuchElementException, IllegalStateException in this code. Would it matter to keep the same order in the main line? Would it matter to keep throws in the main line or not at all? 
    try{         
        pathInput = new Scanner(path);
    }catch(IOException ioException){
        System.err.println("Error opening file. Terminating.");
        System.exit(1);
    }

    System.out.printf("%-10s%-15s%-15s%10s%n", "Port", "Destination",
             "Source", "Data-type");

    //readRecords
    try{
        while(pathInput.hasNext()){ //while there is more to read, display record contents
            System.out.printf("%-10s%-15s%-15s%10s%n", pathInput.next(), 
                    pathInput.next(), pathInput.next(), pathInput.next());
        }
     }catch(NoSuchElementException elementException){
         System.err.println("File improperly formed. Terminating.");
     }catch(IllegalStateException stateException){
         System.err.println("Error reading from file. Terminating.");
     }
 
I would appreciate your answer! Thanks!

原文：https://stackoverflow.com/questions/35071533

更新时间：2023-07-27 18:07

最满意答案

 这个javadocs说：  
 
  “ OffsetDateTime ，“ ZonedDateTime和“ Instant都将时间线上的瞬间存储为ZonedDateTime级的精度， Instant是最简单的，仅代表瞬间， OffsetDateTime将添加到UTC /格林威治的距离，这允许本地日期时间为ZonedDateTime添加了全时区规则。“  
 
 资料来源： https ： //docs.oracle.com/javase/8/docs/api/java/time/OffsetDateTime.html  
 因此， OffsetDateTime和ZonedDateTime之间的区别在于后者包括涵盖夏令时调整的规则。  
 
  在将数据写入日期时应使用OffsetDateTime，但是我不明白为什么。  
 
 一个原因是当地时间抵消的时间总是与时间相同，因此有一个稳定的排序。 相比之下，正面对相应时区规则的调整，具有全时区信息的日期的含义是不稳定的。 （这些确实发生...）  
 如果（例如）在字段上创建日期的数据库索引，则其含义/排序不稳定的日期是有问题的。 

 
 Q: What's the difference between java 8 ZonedDateTime and OffsetDateTime? 
 
The javadocs say this: 
 
 "OffsetDateTime, ZonedDateTime and Instant all store an instant on the time-line to nanosecond precision. Instant is the simplest, simply representing the instant. OffsetDateTime adds to the instant the offset from UTC/Greenwich, which allows the local date-time to be obtained. ZonedDateTime adds full time-zone rules." 
 
Source: https://docs.oracle.com/javase/8/docs/api/java/time/OffsetDateTime.html 
Thus the difference between OffsetDateTime and ZonedDateTime is that the latter includes the rules that cover daylight saving time adjustments and various other anomalies.  
Stated simply: 
 
 Time Zone = ( Offset-From-UTC + Rules-For-Anomalies )  
 
 
 
 Q: According to documentation OffsetDateTime should be used when writing date to database, but I don't get why. 
 
Dates with local time offsets always represent the same instants in time, and therefore have a stable ordering. By contrast, the meaning of dates with full timezone information is unstable in the face of adjustments to the rules for the respective timezones. (And these do happen; e.g. for date-time values in the future.) So if you store and then retrieve a ZonedDateTime the implementation has a problem: 
 
 It can store the computed offset ... and the retrieved object may then have an offset that is inconsistent with the current rules for the zone-id. 
 It can discard the computed offset ... and the retrieved object then represents a different point in the absolute / universal timeline than the one that was stored. 
 
If you use Java object serialization, the Java 9 implementation takes the first approach. This is arguably the "more correct" way to handle this, but this doesn't appear to be documented. (JDBC drivers and ORM bindings are presumably making similar decisions, and are hopefully getting it right.) 
But if you are writing an application that manually stores date/time values, or that rely on java.sql.DateTime, then dealing with the complications of a zone-id is ... probably something to be avoided. Hence the advice. 
Note that dates whose meaning / ordering is unstable over time may be problematic for an application. And since changes to zone rules are an edge case, the problems are liable to emerge at unexpected times. 
 
A (possible) second reason for the advice is that the construction of a ZonedDateTime is ambiguous at the certain points. For example in the period in time when you are "putting the clocks back", combining a local time and a zone-id can give you two different offsets. The ZonedDateTime will consistently pick one over the other ... but this isn't always the correct choice. 
Now, this could be a problem for any applications that construct ZonedDateTime values that way. But from the perspective of someone building an enterprise application is a bigger problem when the (possibly incorrect) ZonedDateTime values are persistent and used later.

Java中抛出异常的顺序(Order of throws exceptions in Java)

最满意答案

相关问答

Java 8日期时间：从ZonedDateTime获取一天的开始时间(Java 8 date-time: get start of day from ZonedDateTime)[2023-02-16]

在Java中将字符串转换为OffsetDateTime(Convert string to OffsetDateTime in Java)[2023-11-22]

如何使用ThreeTenABP将ZonedDateTime / OffsetDateTime转换为日期？(How to convert ZonedDateTime/OffsetDateTime to Date using ThreeTenABP?)[2022-05-06]

将OffsetDateTime转换为UTC时间戳(Convert OffsetDateTime to UTC Timestamp)[2022-06-28]

java 8 ZonedDateTime和OffsetDateTime有什么区别？(What's the difference between java 8 ZonedDateTime and OffsetDateTime?)[2022-05-25]

你能直接将ISO 8601时间戳映射到OffsetDateTime或ZonedDateTime与Retrofit 2和Gson吗？(Can you directly map ISO 8601 timestamps into OffsetDateTime or ZonedDateTime with Retrofit 2 and Gson?)[2023-12-12]

Java8- ZonedDateTime，DateTimeFormatter无法识别格式(Java8- ZonedDateTime with DateTimeFormatter not recognizing the format)[2024-03-16]

OffsetDateTime解析(OffsetDateTime parsing)[2023-10-20]

如何确定ZonedDateTime是否为“今天”？(How to determine if ZonedDateTime is “today”?)[2023-09-25]

Java 8的ZonedDateTime在转换时是否考虑了夏令时？(Does Java 8's ZonedDateTime take into account daylight savings when converting?)[2022-02-16]

相关文章

最新问答