Utilisation de try-catch java

Donc je viens dans les bases de try-catch déclarations en java. Je suis encore un peu confus sur quelques différences dans la syntaxe. Voici le code im essayant d'analyser et de comprendre. Aussi, quelle est la différence entre l'utilisation d'essayer ensuite catch(Exception e) comparativement à dire juste jette...ou throw new... à Partir de ma compréhension, un try catch est essentiellement un moyen de gérer l'erreur par la sortie d'un message ou de passer à une autre méthode. Cependant, je pense que im coincé sur la syntaxe de ses aspects. Tout commentaires constructifs ou des exemples simples sont les bienvenus, les gars. Quelques précisions sur ce concept aussi bien que ce qui se passe avec l'exemple de code à partir de mon livre serait appréciée.

/* Invalid radius class that contains error code */
public class InvalidRadiusException extends Exception {
     private double radius;

/** Construct an exception */
public InvalidRadiusException(double radius) {
       super("Invalid radius " + radius);
       this.radius = radius;
}

/** Return the radius */
public double getRadius() {
    return radius;
 }
}


public class CircleWithException {
/** The radius of the circle */

private double radius;

/** The number of the objects created */
private static int numberOfObjects = 0;

/** Construct a circle with radius 1 */
public CircleWithException() throws InvalidRadiusException {
       this(1.0);
  }

/** Construct a circle with a specified radius */
public CircleWithException(double newRadius) throws InvalidRadiusException {
          setRadius(newRadius);
          numberOfObjects++;
}

/** Return radius */
public double getRadius() {
     return radius;
}

/** Set a new radius */
public void setRadius(double newRadius)
    throws InvalidRadiusException {
if (newRadius >= 0)
  radius =  newRadius;
else
  throw new InvalidRadiusException(newRadius);
}

/** Return numberOfObjects */
public static int getNumberOfObjects() {
      return numberOfObjects;
}

/** Return the area of this circle */
public double findArea() {
    return radius * radius * 3.14159;
 }
}
Avez-vous lu ceci?
correct. Cependant, son, quand vous jetez quelque chose, attraper, puis le transmettre à plus de méthodes, de l'utiliser dans if-else, ou simplement dire le nom de la méthode + lance qui est ce qui est moi.
essayez de chat.stackexchange.com
nous sommes autorisés à poursuivre cette discussion dans le chat, je crois.
votre analogie ne fait pas de sens.

OriginalL'auteur zeesh91 | 2014-03-25

  1. 8

    Explication

    De la La documentation Java:

    [Le essayer bloc] contient un ou plusieurs juristes
    les lignes de code qui pourrait jeter une exception. (La capture, et enfin
    les blocs sont expliquées dans les deux prochains paragraphes.)

    Une exception est un type spécial d'objet. Lorsque vous écrivez new Exception(), vous créez un nouvel objet d'exception. Lorsque vous écrivez throw new Exception() vous créez un nouveau message d'erreur, puis de le jeter à la plus proche bloc try-catch, abandonner le reste de votre code.

    Lorsque vous jeter une exception, il obtient pris par le bloc try-catch qu'il est imbriqué dans (à l'intérieur). C'est, en supposant que le bon bloc catch pour que l'exception est enregistré. Si le code n'est pas enveloppé dans un bloc try-catch, le programme arrête automatiquement dès qu'une erreur est levée. Utiliser un try-catch autour d'un code ou d'une méthode qui peut renvoyer une erreur, surtout en raison de la saisie de l'utilisateur (dans la raison).

    Quelques exceptions doivent être prises, d'autres sont facultatives pour les attraper. (vérifié vs non cochée).

    Lorsque vous ajoutez throws à une signature de méthode, vous annoncer à d'autres méthodes qui, si elles font appel à cette méthode, il a le potentiel pour jeter un vérifié exception (il n'est pas nécessaire non cochée). Remarquez comment il est throws pas throw. Ce n'est pas de faire une action, il décrit qu'il n'est parfois une action.

    Vous utilisez cette fonctionnalité lorsque vous ne voulez pas de capture de l'erreur à l'intérieur de cette méthode, mais permettre à la méthode de cet appel que votre méthode de capture de l'erreur eux-mêmes.

    Exceptions sont une façon de rendre votre programme de répondre de façon cohérente à inattendus ou invalide les situations et sont particulièrement utiles lors de la saisie de l'utilisateur est requis, mais il est également utile dans d'autres situations comme Fichier d'entrée/sortie.

    Exemples

    public CircleWithException() throws InvalidRadiusException {
       this(1.0);
}

    Ici, le CircleWithException() a le potentiel pour jeter un InvalidRadiusException (sans doute, la ce(1.0) parfois, jette un InvalidRadiusException.)

    Le code de l'appel de cette méthode doit avoir:

    try {
    new CircleWithException(); //This calls the method above
} catch (InvalidRadiusException e) { //The object "e" is the exception object that was thrown.
    //this is where you handle it if an error occurs
}

    Comme je l'ai dit avant, une Exception est juste un type spécifique de l'objet qui s'étend Exception

    /* Invalid radius class that contains error code */
public class InvalidRadiusException extends Exception {
     private double radius;

/** Construct an exception */
public InvalidRadiusException(double radius) {
       super("Invalid radius " + radius);
       this.radius = radius;
}

/** Return the radius */
public double getRadius() {
    return radius;
 }
}

    Le code ci-dessus définit un nouveau type d'Exception spécifique à votre programme/de l'application. Il existe de nombreuses exceptions prédéfinies dans la Java de la Bibliothèque Standard, mais souvent vous avez besoin pour créer votre propre.

    Pour lever cette exception, vous devez d'abord créer un InvalidRadiusException objet, puis de le jeter:

    throw new InvalidRadiusException(1.0);

    OriginalL'auteur sinθ

  2. 3

    Vous pouvez déclarer une méthode pour jeter une exception si vous ne peut pas (ou il n'est pas pratique) pour gérer l'exception à l'intérieur de la méthode.

    Dans votre cas, vous appelez la méthode setRadius à l'intérieur du constructeur. Si vous pensez que c'est pratique pour gérer l'exception (qui est jeté par setRadius) dans le constructeur, vous pouvez utiliser un try-catch clause:

    public CircleWithException(double newRadius) throws InvalidRadiusException {
    try {
        setRadius(newRadius);
        numberOfObjects++;
    } catch (InvalidRadiusException e) {
        setRadius(0); //for example
    }
}

    La catch bloc contient ce que vous voulez faire si une exception a été levée. Dans ce cas, je suis le rayon de 0, mais vous pouvez le changer.

    Rappelez-vous que cela dépend de vos classes de mise en œuvre et la façon dont vous voulez qu'ils travaillent. Si vous ne voulez pas le constructeur à gérer cette exception, vous pouvez le jeter (comme vous le faites déjà) et de les traiter dans d'autres méthodes.

    quand vous dites jette dans votre première ligne, r u déclarant que si il jette InvalidRadiusException ou qu'il pourrait jeter? Dans ce cas, il est là comme une mesure de sécurité?
    Quelques exemples de ce que je voulais dire, sont vos des constructeurs. Ils ont tous les deux jet l'exception InvalidRadiusException. Mais notez qu'ils ne le font pas "directement". Ils appeler une méthode (qui, en fait, a la throw new InvalidRadiusException; ligne), mais ne pas s'en occuper.

    OriginalL'auteur Christian

  3. 2

    "jette" est une déclaration d'une méthode de lancer de certaines exceptions. Ceci est renforcé par le compilateur java pour les exceptions, et pas pour les erreurs ou non des exceptions.

    "throw new" sont deux mots-clés en java on peut donc décomposer...

    • "jeter" est un opérateur qui déclenche une exception
    • "nouveau" est un opérateur qui crée une nouvelle instance d'un objet

    la "essayer" bloc vous permet d'exécuter les méthodes qui déclarent lancer des exceptions, et c'est là que vous utilisez la "capture" de la clause, afin d'intercepter les exceptions lancées.

    En outre, il est également le try-with-resources bloc où vous pouvez utiliser un bloc try pour fonctionner sur un bien de consommation(par exemple, un cours d'eau) qui implémente AutoCloseable, puis le fermer.

    Il y a aussi le "enfin" la clause d'un essayer bloc, ce qui vous permet d'exécuter le nettoyage ou toute autre méthode qui DOIT s'exécuter après un essayer bloc, indépendamment de savoir si les exceptions se produisent ou non.

    OriginalL'auteur rpg711

  4. 2

    Il existe deux types d'exceptions

    1) Décochée. Elles sont définies par les Error et RuntimeException les classes et de tous leurs sous-classes. Java n'est pas de vous forcer à une poignée de ces exception en quelque sorte.

    2) Vérifié. Celles-ci sont définies être le Throwable de classe et de toutes ses sous-classes qui n'entrent pas dans la catégorie définie en (1). Java vous oblige à gérer ces exceptions avec un try/catch. Si vous appelez une méthode qui peut lancer une exception (défini par le throws mot-clé) à l'extérieur d'un bloc try votre code ne compilera pas.

    throws : C'est une façon de déclarer qu'une méthode peut potentiellement jeter une exception qui doit être pris avec un try/catch. Par exemple 

    public void doSomething() throws MyException { ... }

    est une déclaration d'une méthode qui peut éventuellement jeter une instance de MyException.

    try/catch/finally : C'est un moyen de gérer les exceptions qui peuvent être produites par une sorte de code. Cody vous essayez d'exécuter va dans le try bloc, le code de gestion d'erreur qui va dans la catch bloc. L'option finally bloc est quelque chose qui va être exécutée indépendamment de si oui ou non une exception est levée. En fait, le bloc finally sera appelé même si vous faites une return à l'intérieur de votre try ou votre catch. Par exemple

    try {
    doSomething();
} catch (MyException exception) {
    exception.printStackTrace();
}

    ou un exemple d'utilisation de finally :

    MyResource myResource = getMyResource();
try {
    myResource.open();
    doStuffWithMyResource(myResource);
} catch (Exception exception) {
    exception.printStackTrace();
} finally {
    if (myResource.isOpen()) {
        myResource.close();
    }
}

    OriginalL'auteur SamYonnou