Valeurs de base Java : mots-clés de gestion des exceptions...-javaDidacticiel-php.cn

On dit que le langage Java est très robuste, comme le mécanisme de récupération de place, le modèle de mémoire, la gestion des exceptions, la conversion de type forte, la multiplateforme, etc., ce qui rend le langage Java populaire. Aujourd'hui, nous allons d'abord parler du mécanisme de gestion des exceptions de Java try catchfinally throw throws. Habituellement, nous semblons sous-estimer ces cinq mots-clés. Lors du développement de systèmes d'application, une bonne gestion des exceptions est particulièrement importante pour le développement ultérieur, la maintenance, la mise à niveau et l'expérience utilisateur du système.

Les exceptions ont une fonctionnalité très importante Si vous ne l'attrapez pas à partir de l'emplacement où l'exception se produit dans la méthode principale en haut, la jvm finira par générer des informations sur l'exception pour vous. . Oups. De plus, le thread est déconnecté et le code suivant n'est plus exécuté A partir de là, il a disparu silencieusement dans la vaste mer de la JVM. Dans un projet précédent de notre société, le front-end ajax a demandé au contrôle d'effectuer le paiement. Parce que le catch du contrôle a lancé un pointeur nul, la page front-end était bloquée. Solution : étant donné que la couche de contrôle est généralement la couche supérieure, elle l'est. Il est préférable d'attraper tout ce qui est possible. Lorsqu'une exception se produit, d'autres objets de niveau non supérieur peuvent continuer à être lancés ou lancés vers le haut. Il est également préférable de définir un délai d'attente pour chaque ajax.

Présentons brièvement throw et throws :

throw : lance une exception dans le corps de la méthode. L'objet d'exception réel est généralement une instance d'exception que vous étendez. est placé après le nom de la méthode, ce qui signifie que si une exception se produit dans cette méthode, je ne veux pas ou ne peux pas la gérer, et laisse à l'appelant le soin de la gérer. Vous pouvez lancer une exception d'exécution (. non coché) tel que ClassNotFoundException, NumberFromartException ou throws ou throw +try ou throw+throws gère une exception vérifiée telle que : IOExcepion, SocketException, des exceptions telles que des classes d'exceptions héritées. La différence est que les exceptions vérifiées doivent être gérées (soit les tentatives, soit les lancers continuent d'être lancés, sinon la compilation ne réussira pas), tandis que les exceptions d'exécution n'ont pas besoin d'être gérées. La conséquence de ne pas les gérer est qu'après qu'une exception se produit, le jvm signale un message d'exception et le thread est interrompu. Il n'est généralement pas recommandé d'utiliser les mots-clés throw et throws dans le code, et il est recommandé que toutes les exceptions soient résolues sur place. Sachez simplement comment l'utiliser, pas besoin de trop expliquer.

Essayez les règles de combinaison : 1, try{}catch(){} 2, try{}catch(){}finally{} 3, try{}finally{}, 1 et 2 peuvent être utilisés pour attraper Il y a plusieurs

amis, mange quelques marrons :

1, pas de combinaison d'essai

public class CatchExecuteJustOne {
　public void methodOne( ){
System.out.println("into methodOne method");
int one=1/0;
System.out.println("end methodOne method"); //Aucune sortie n'essaye. combinaison, le thread a été déconnecté après que l'erreur a été signalée
}
public static void main(String[] args) {
CatchExecuteJustOneS cejo = new CatchExecuteJustOneS();
cejo.methodOne();

System.out.println("end main method"); //Aucune sortie, aucune combinaison d'essai, le fil d'erreur a été déconnecté
}
>

Sortie :

Dans la méthode methodOne
Exception dans le fil "main" java.lang.ArithmeticException : / par zéro
à priv.lilei.exception.example_1.CatchExecuteJustOneS.methodOne(CatchExecuteJustOneS.java:6)
chez priv. lilei.exception.example_1.CatchExecuteJustOne.main(CatchExecuteJustOne.java:19)

2.1, il y a le cas de combinaison d'essai 1

classe publique CatchExecuteJustOne {
public void methodOne(){
　　System.out.println("into methodOne method");
　try{
　　int one=1/0;
　　}catch(Exception e){
　　 System.out.println("methodOne try to");
}
System.out.println("end methodOne method" ) {
CatchExecuteJustOne cejo = new CatchExecuteJustOne( );
cejo.methodOne();
System.out.println("end main method");
}
}

Sortie :

dans la méthode methodOne

methodOne essayez de

terminer la méthode MethodOne

terminer la méthode principale

2.2, il y a le cas de combinaison d'essai 2

classe publique CatchExecuteJustOne {

public void methodOne(){

System.out.println("into methodOne method");

int one=1/0;
System.out.println("end methodOne method"); //Le fil de discussion ne sera pas exécuté et l'erreur sera interrompue et renvoyée directement
>

public static void main(String[] args) {
　try{
　　CatchExecuteJustOne cejo = new CatchExecuteJustOne();
cejo.methodOne();
}catch(Exception exception){
System.out.println("into main method catch"); // exécutera l'essai de la méthode ci-dessus Exception signalée
}
System.out.println("end main method"); // Exécutera la tentative d'exception signalée par la méthode ci-dessus
}
}

Sortie :

dans la méthode methodOne
dans la méthode principale catch
end main method

2.3, avec la combinaison de cas d'essai 3, l'exception ne sera interceptée qu'une seule fois par le dernier catch . Comme switch case, la syntaxe est la même que if() if else(){} if()else if{}

public class CatchExecuteJustOne {
public void methodOne() {
System.out.println("into methodOne method");
try{
int one=1/0;
}catch(ArithmeticException e){
System.out.println ("catch 1 ");
}catch (Exception e) {
System.out.println("catch 2");//Le catch 1 précédent qui a été exécuté ne sera pas exécuté
}
}

public static void main(String[] args) {
CatchExecuteJustOne cejo = new CatchExecuteJustOne();

essayez {
cejo.methodOne();
} catch (Exception e) {
System.out.println("man catch");//n'exécutera pas le catch 1 déjà exécuté
}

System.out.println( "end main method") ;
}
}

Sortie :

dans la méthode methodOne
catch 1
fin main method

2.4 Il existe le cas de combinaison try 4, combinaison Try{}finally{}, le thread sera déconnecté lorsque final ne renvoie pas de valeur, mais lorsqu'il y a une valeur de retour dans final, le thread ne sera pas déconnecté mais le suivant Le code ne sera pas exécuté. Il est recommandé d’utiliser cette combinaison avec parcimonie.

//Aucune valeur de retour

classe publique CatchExecuteJustOne {
　public void methodOne(){ //Aucune valeur de retour
　System.out .println("dans la méthode methodOne");
try{
int one=1/0;
}finalement{
System.out.println("dans la méthodeOne enfin");
>
　　System.out.println("end methodOne method"); //Le thread ne s'exécutera pas et l'erreur signalée ci-dessus sera interrompue et lancée directement
}

public static void main( String[] args ) {
　CatchExecuteJustOne cejo = new CatchExecuteJustOne();
　cejo.methodOne();
　System.out.println("end main method");//Le thread d'exécution ne signalera pas une erreur et sera interrompu et jeté directement Hors de
}
}

Sortie sans valeur de retour :

dans la méthode methodOne
Exception dans le thread "main" dans methodOne enfin
java.lang. ArithmeticException : / par zéro
à priv.lilei.exception.example_1.CatchExecuteJustOne.methodOne(CatchExecuteJustOne.java:14)
à priv.lilei.exception.example_1.CatchExecuteJustOne.main (CatchExecuteJustOne.java:23)

a une valeur de retour :

classe publique CatchExecuteJustOne {
public String methodOne(){
System.out.println ("dans la méthode methodOne");
try{
System.out.println("1");
int one=1/0;
System.out.println("2") ;//Le fil de discussion ci-dessus ne sera pas exécuté L'erreur est interrompue et renvoyée directement
}finally{
System.out.println("into methodOne finalement");//affichera
renvoie "1" ;
}
}

public static void main(String[] args) {
CatchExecuteJustOne cejo = new CatchExecuteJustOne();
cejo.methodOne();
Système .out.println("end main method" );//Il sera exécuté car il y a un essai ci-dessus et la méthode a une valeur de retour
}
>

Il y a une sortie avec une valeur de retour :

into methodOne method
1
into methodOne enfin
end main method

2.5, la combinaison avec enfin est toujours exécutée , et s'il y a une valeur de retour, elle sera exécutée avant de revenir, sauf en cas de comportement particulièrement violent tel que system.exit(0); ou si elle peut être déconnectée, ou si la mémoire peut déborder ou autre erreur.

combinaison de retour

2.5.1 Dans les deux cas suivants, il existe des différences dans l'attribution de valeurs aux variables à nouveau dans catch et enfin lorsqu'il y a pas d'exception et quand il y a une exception. S'il n'y a pas d'exception, l'affectation échoue à nouveau, mais s'il y a une exception, l'affectation réussit à nouveau.

1 Aucune exception

classe publique CatchExecuteJustOne {
public String methodOne(){
String a =" ";
System.out.println("into methodOne method");
try{
a="a";
return a;
}catch(ArithmeticException e){
System.out.println("catch 1");
}finally {
System.out.println(1);
a="a2" //Aucune erreur ne sera signalée Aucune valeur d'attribution to a;
System.out.println(2);
}
System.out.println(3); //Le retour ci-dessus, une méthode ne sera pas exécutée et a déjà été renvoyée
return a;
}

public static void main(String[] args) {
CatchExecuteJustOne cejo = new CatchExecuteJustOne();
System.out.println(cejo.methodOne());
}
}

La sortie de return sans exception dans try :

into methodOne method
1
2
a

2 Il y a une situation anormale

public class CatchExecuteJustOne {
public String methodOne(){
String a="";
System.out.println("into methodOne method");
try{
a ="a";
int i=1/0;
return a;
}catch(ArithmeticException e){
System.out.println("catch 1");
} enfin {
System.out.println(1);
a="a2"; //S'il y a une exception, elle sera réaffectée à une variable
System.out.println(2);
>
System.out.println(3); //Il affichera que l'exception interceptée n'est pas renvoyée à partir du premier return a ci-dessus mais à partir du return suivant
return a;
}

public static void main(String[] args) {
CatchExecuteJustOne cejo = new CatchExecuteJustOne();
System.out.println(cejo.methodOne());
}
>