JAVA：尝试捕获异常

Question

I am unsure as to the best way to throw multiple exceptions in the main method. This is the approach I have taken, I was wondering if this way is correct

  public static void main(String[] args)  {

        File nFile = new File("ProductData.txt");
        File file = new File("CustomerData.txt");
        File pFile = new File("PurchaseOrderDataFile.txt");
        try {
            Scanner pScan = new Scanner(pFile);
            Scanner scan = new Scanner(file);
            //Makes ElectronicsEquipmentSupplier object with the month and year product array
            ElectronicsEquipmentSupplier ees = new ElectronicsEquipmentSupplier
        (1, 12, InputFileData.readProductDataFile(nFile));
            //Adds successive customer records to suppliers customer list
            for (int i = 0; i < 28; i++) {
                ees.addNewCustomer(InputFileData.readCustomerData(scan));
            }
            for (int i = 0; i <= 24; i++) {
                String poByMonth = InputFileData.readPurchaseOrderDataFile(pScan); //Brings list in by months
                String[] purchaseOrder = poByMonth.split("\\s+");
                ees.startNewMonth(); //When the months are split by the @ it adds a new month
                for (int j = 0; j <= purchaseOrder.length - 1; j++) {
                    String[] result = purchaseOrder[j].split("#");
                    int qty = Integer.parseInt(result[3]);
                    ees.addNewPurchaseOrder(result[0], result[1], result[2], qty);
                    double orderTotal = 0;
                    for (Product p : ees.getRangeOfProducts()) {
                        if (p.getProductCode().equals(result[2])) {
                            orderTotal = p.getPricePerUnit() * qty;
                        }
                    }
                    CustomerDetails customer = ees.getDetails().findCustomer(result[1]);
                    customer.setTotalPrice(orderTotal + customer.getTotalPrice());
                    if (result[1].substring(0, 1).equals("P")) {
                        System.out.println("Customer ID: " + (result[1]));
                        System.out.println("Discount: " + customer.getDiscountRate());
                    }
                }
            }
        }   //Catches exceptions
        catch(IllegalCustomerIDException| IllegalProductCodeException |
                IncorrectPurchaseOrderException | CustomerNotFoundException | IOException ex){
            //Outputs exceptions if they are caught 
            System.out.println(ex);
        }
    }

As you can see I have put it all in one large try catch and thrown all the exceptions at once. It seemed a nice neat way of doing it but I'm unsure as to whether or not it is good practice

Answer 1

You could also do something like:

public static void main(String[] args)  {
    try {
        ...
    } catch(IllegalCustomerIDException e) {
       ...
    } catch(IllegalProductCodeException e) {
       ...
    } catch(IncorrectPurchaseOrderException e) {
       ...
    } catch(CustomerNotFoundException e) {
       ...
    } catch(IOException e) {
       ...
    }
}

Answer 2

I hope this explains when you should catch exceptions: When i know how to handle the exceptions:

class SomeWeirdName{
  void someMethod(){
    try{
      // your logic here >_<
    }
    catch(ExceptionTypeA A){
      doSomething1();
    }
    catch(ExceptionTypeB B){
      doSomething2();
    }finally{
      somethingElse();
    }
  }
}

If I don not know how to handle the exception:

    class SomeWeirdName{
      // i don't know how to handle the exception, so no need to catch them
      // maybe someone else is gonna catch the exception later in some 
      // other class
      void someMethod() throws ExceptionTypeA, ExceptionTypeB{        
          // your logic here >_<
      }
    }

Like you see, when or how you catch the exception "should" depend on how you "handle" that exception. Hope it helps.

Answer 3

You could just do a catch (Exception e){} to catch all of them at once.

However, most of the time it's more useful to actually do something with a exception when/where it happens, instead of just catching them all at the end.