Java implémentant le traitement des exceptions

Question

J'essaie d'implémenter une exception OutOfStockException lorsque l'utilisateur tente d'acheter plus d'éléments que ce qui est disponible. Je ne suis pas sûr si ma mise en œuvre est correcte. Cela vous semble-t-il correct?

public class OutOfStockException extends Exception { 


    public OutOfStockException(){ 
     super(); 
    } 

    public OutOfStockException(String s){ 
     super(s); 
    } 
} 

C'est la classe où je dois le tester:

import javax.swing.JOptionPane; 

public class SwimItems { 
    static final int MAX = 100; 


    public static void main (String [] args) 
    { 
     Item [] items = new Item[MAX]; 
     int numItems; 

     numItems = fillFreebies(items); 
     numItems += fillTaxable(items,numItems); 
     numItems += fillNonTaxable(items,numItems); 

     sellStuff(items, numItems); 
    } 

    private static int num(String which) { 
     int n = 0; 
     do { 
         try{ 
      n=Integer.parseInt(JOptionPane.showInputDialog("Enter number of "+which+" items to add to stock:")); 
         } 
         catch(NumberFormatException nfe){ 
          System.out.println("Number Format Exception in num method"); 
         } 
     } while (n < 1 || n > MAX/3); 
     return n; 
    } 

    private static int fillFreebies(Item [] list) 
    { 
     int n = num("FREEBIES"); 
     for (int i = 0; i < n; i++) 
        try{ 
      list [i] = new Item(JOptionPane.showInputDialog("What freebie item will you give away?"), 
      Integer.parseInt(JOptionPane.showInputDialog("How many do you have?"))); 
        } 
        catch(NumberFormatException nfe){ 
         System.out.println("Number Format Exception in fillFreebies method"); 
        } 
        catch(ArrayIndexOutOfBoundsException e){ 
         System.out.println("Array Index Out Of Bounds Exception in fillFreebies method"); 
        } 

     return n; 
    } 

    private static int fillTaxable(Item [] list, int number) 
    { 
     int n = num("Taxable Items"); 
     for (int i = number ; i < n + number; i++) 
        try{ 
      list [i] = new TaxableItem(JOptionPane.showInputDialog("What taxable item will you sell?"), 
       Double.parseDouble(JOptionPane.showInputDialog("How much will you charge (not including tax) for each?")), 
        Integer.parseInt(JOptionPane.showInputDialog("How many do you have?"))); 
        } 
        catch(NumberFormatException nfe){ 
         System.out.println("Number Format Exception in fillTaxable method"); 
        } 
        catch(ArrayIndexOutOfBoundsException e){ 
         System.out.println("Array Index Out Of Bounds Exception in fillTaxable method"); 
        } 

     return n; 
    } 


    private static int fillNonTaxable(Item [] list, int number) 
    { 
     int n = num("Non-Taxable Items"); 
     for (int i = number ; i < n + number; i++) 
        try{ 
      list [i] = new SaleItem(JOptionPane.showInputDialog("What non-taxable item will you sell?"), 
        Double.parseDouble(JOptionPane.showInputDialog("How much will you charge for each?")), 
        Integer.parseInt(JOptionPane.showInputDialog("How many do you have?"))); 
        } 
        catch(NumberFormatException nfe){ 
         System.out.println("Number Format Exception in fillNonTaxable method"); 
        } 
        catch(ArrayIndexOutOfBoundsException e){ 
         System.out.println("Array Index Out Of Bounds Exception in fillNonTaxable method"); 
        } 

     return n; 
    } 


    private static String listEm(Item [] all, int n, boolean numInc) 
    { 
     String list = "Items: "; 
     for (int i = 0; i < n; i++) 
     { 
        try{ 
      list += "\n"+ (i+1)+". "+all[i].toString() ; 
      if (all[i] instanceof SaleItem) list += " (taxable) "; 
      if (numInc) list += " (Number in Stock: "+all[i].getNum()+")"; 
        } 
        catch(ArrayIndexOutOfBoundsException e){ 
         System.out.println("Array Index Out Of Bounds Exception in listEm method"); 
        } 
        catch(NullPointerException npe){ 
         System.out.println("Null Pointer Exception in listEm method"); 
        } 

     } 
     return list; 
    } 



    private static void sellStuff (Item [] list, int n) { 

     int choice; 
     do { 
        try{ 
      choice = Integer.parseInt(JOptionPane.showInputDialog("Enter item of choice: "+listEm(list, n, false))); 
        } 
        catch(NumberFormatException nfe){ 
         System.out.println("Number Format Exception in sellStuff method"); 
        } 

     }while (JOptionPane.showConfirmDialog(null, "Another customer?")==JOptionPane.YES_OPTION); 

     JOptionPane.showMessageDialog(null, "Remaining "+listEm(list, n, true)); 

     } 

} 

Answer 1

La mise en œuvre semble bien; vous n'avez pas à faire grand-chose dans une classe d'exception. Vous pourriez envisager d'ajouter des membres pour ce qui était en rupture de stock, combien ont été demandés et combien il y en avait en stock lorsque la demande a été faite pour que le code qui attrape l'exception ait accès à cette information. Ainsi, par exemple, ici, j'ai un code article de stock:

public class OutOfStockException extends Exception { 

    private int stockCode; 

    public OutOfStockException(int stockCode){ 
     super(); 
     this.stockCode = stockCode; 
    } 

    public OutOfStockException(String s){ 
     super(s); 
     this.stockCode = stockCode; 
    } 

    public int getStockCode() { 
     return this.stockCode; 
    } 
} 

Vous pouvez ensuite créer un comme ceci:

throw new OutOfStockException(StockCodes.WIDGET, "Out of widgets"); 

Mais c'est à vous, et à ce moment-là, il est juste conception de classe comme rien d'autre.

Plusieurs fois, avec ce genre de choses, je ne inclure des constructeurs avec les différentes parties, et ensuite la classe elle-même générer le message pour le message ExceptiongetMessage sous-jacent. Donc:

public class OutOfStockException extends Exception { 

    private int stockCode; 

    public OutOfStockException(int stockCode){ 
     super("Out of " + StockCodes.getDescription(stockCode)); 
     this.stockCode = stockCode; 
    } 

    public int getStockCode() { 
     return this.stockCode; 
    } 
} 

// Throwing one: 
throw new OutOfStockException(StockCodes.WIDGETS); 

Mais encore une fois c'est juste la conception de classe à ce stade. Tout cela mis à part, et c'est un peu hors sujet, mais être en rupture de stock sur un article me semble être une situation normale, pas exceptionnelle; Êtes-vous sûr qu'une exception est vraiment la bonne façon de le modéliser?

Answer 2

Oui, votre exception est correctement implémentée.

Cependant, je proposerais y compris plus d'informations à ce:

• le produit en question
• le nombre d'articles tenté de commander
• le nombre réel d'éléments restants

par exemple, si le produit "Vélo" a 2 objets restants, mais que l'on essaie d'en commander trois, l'exception serait construite et lancée comme

throw new OutOfStockException(product, requestedQuantity, actualQuantity) 

Answer 3

Votre exception semble correcte. Cependant, je ne suis pas sûr de vos classes SaleItem et TaxableItem.

if (all[i] instanceof SaleItem) list += " (taxable) "; 

est une odeur de code - avoir à vérifier l'instance de la classe avant de faire quelque chose (et je ne suis pas sûr que le nom a un sens donné ci-dessus). Pourquoi ne pas surcharger les méthodes appropriées sur la classe pour faire ce qui précède automatiquement pour la sous-classe appropriée.

Answer 4

Je ne suis pas d'accord avec l'utilisation de l'exception ici.Vous ne devriez en utiliser qu'un pour des conditions exceptionnelles comme le suggère la nomenclature et non pour le contrôle du flux car cela rendra votre code beaucoup plus agréable à lire. De plus, les exceptions ne sont pas optimisées par la JVM et, en tant que telles, s'exécutent beaucoup plus lentement.