Zachytávání výjimek - Builder.cz - Informacni server o programovani

Odběr fotomagazínu

Fotografický magazín "iZIN IDIF" každý týden ve Vašem e-mailu.
Co nového ve světě fotografie!

 

Zadejte Vaši e-mailovou adresu:

Kamarád fotí rád?

Přihlas ho k odběru fotomagazínu!

 

Zadejte e-mailovou adresu kamaráda:

Soutěž

Sponzorem soutěže je:

IDIF

 

Kde se koná výstava fotografií Luďka Vojtěchovského?

V dnešní soutěži hrajeme o:



Java

Zachytávání výjimek

java

20. února 2002, 00.00 | V tomto díle se budeme zabývat zachytáváním výjimek a způsobem jejich předávání výše a jejich ošetření ve všech možných částech. S tím bezprostředně souvisí blok try – catch resp. try – catch – finally, který je také na programu.

Vyskytne-li se v kódu výjimka, máme na výběr několik způsobů, jak na ni zareagovat:

  • zachycení i ošetření provedeme kompletně tam, kde se vyskytla
  • předávání o úroveň výše tj. té metodě, která volá tu naši. Bez ohledu na to, zda ji v této metodě už ošetřil či vůbec ošetří.
  • nebudeme na ni reagovat
Ošetření výjimky v metodě

Tento způsob patří k těm nejprimitivnějším a také nejpoužívanějším. Podívejme se tedy spolu, jakým způsobem můžeme ošetřit výjimku přímo v metodě, ve které vznikla.

import  java.awt.*;

public  class  ip
{
     public  static  void  main(String  [] args) {
          try  {
               System.out.println(java.net.InetAddress.getLocalHost().getHostAddress());
          }
          catch  (java.net.UnknownHostException e) {
               System.out.println("Unknown Host");
          }
     }
}

Celé to spočívá v bloku try – catch. Kde v try máte kód u kterého se zachytává výjimka, kterou máte definovanou za catch. Možná jsem na začátek použil nevhodný příklad v tom, že se neodkazuji na přímo definovanou výjimku. Z části to je záměr, abyste si uvědomili, že se mohu odkazovat na různé balíky. Celé to lze vyřešit tak, že se to rozšíří o import java.net.*;. Pak bych se mohl odkazovat přímo a vypadalo by to asi takto (což je typičtější):

import  java.awt.*;
import  java.net.*;

public  class  ip
{
     public  static  void  main(String  [] args) {
          try  {
               System.out.println(InetAddress.getLocalHost().getHostAddress());
          }
          catch  (UnknownHostException e) {
               System.out.println("Unknown Host");
          }
     }
}

Předání výjimky výše

Další způsobem, jak zpracovat výjimku je její předání výše. Před předáním je samozřejmě možné provést množství úprav, ať již s programem samotným (opravení stavu tak, aby program nespadl) či s předáním výjimky. Např. je možné odeslat úplně jinou výjimku, která bude lépe charakterizovat co se s metodou dělo. Takto předaná výjimka zajistí, že se o vzniklé výjimce dozví i ten kdo volá onu metodu.

import  java.io.*;

public  class  Reader {

     public  static  int readNum() throws  IOException {
          byte[] arr = new  byte[10];
          String  read;
          int i;
          try  {
               System.in.read(arr);
               read = new  String(arr).trim();
               i = Integer.valueOf(read).intValue();
               return  i;
          }
          catch  (IOException e) {
               System.out.println("I/O ERR");
               throws  e;
          }
     }

     public  static  void  main(String  [] args) {
          System.out.print("Type number: ");
          try  {
               int i = readNum();
               System.out.println(i);
          }
          catch  (IOException e) {
               System.out.println("Sorry, method failed!");
          }
     }
}

Pozn.: je dobré si uvědomit, že metoda nutně nemusí předávat jen jeden typ výjimky. Sama o sobě jich může předávat hned několik viz. následující:

...
public  int bookBook(int ISBN, int userID) throws  UnknownISBNException, UnknownUserException, BookIsAvailableException, BookIsAlreadyBookedException {
...

Block try – finally

S blokem try – catch nenávratně souvisí i blok try – finally resp. try – catch – finally. Takovýto blok, jak jistě víte, se bude hodit na ošetření, takových konstrukcí, která potřebují na svém závěru provést některé kroky a to bez ohledu na to, zda proběhli v pořádku či ne. Oněmi kroky může být například uzavření spojení či cokoliv jiného.

...
void  draw(Graphics g, int x, int y, int w, int h) {
     Graphics ng = g.create();
     try  {
          ng.translate(x, y);
          scalePolygon((float) ((float) w / (float) 10 ), (float) ((float) h / (float) 20));
          ng.drawPolygon(p);
     }
     finally  {
          ng.dispose();
     }
}
...

Asi je jasné, že v bloku try – catch – finally se může vyskytovat více catch. To se obecně nazývá selekcí. Což znamená, že si vybíráte výjimky, na které chcete nějak reagovat.

import  java.io.*;

public  class  MyFileRead
{
     public  static  void  main(String  [] args)
     {
     try  {
          BufferedReader myfile = new  BufferedReader (new  FileReader ("a.txt"));
          String  S;
          int i;
          while  ((S = myfile.readLine()) != null  ) {
               i = Integer.valueOf(S).intValue();
               System.out.println(S);
          }
          myfile.close();
     }
     catch  (NumberFormatException e) {
          System.out.println("Řetězec \"" +e.getMessage() +"\" není číslo!");
     }
     catch  (IOException e) {
          System.out.println("I/O ERR");
     }
     }
}

Opakem k selekci je seskupování. To nám umožňuje, díky pyformismu, reagovat na množství výjimek jednotně. Lze to použít v situacích, kdy je nutné, aby celek proběhl bez jakékoliv výjimky. A kdy je mi vcelku jedno jaká výjimka vznikla.

     try  {
          ...
     }
     catch  (RunTimeException e) { // či ještě lépe Exception
          System.out.println("Method failed!); // bez toho abych hledal proč
     }

V rámci catch lze provádět selekci i seskupování zároveň. Jen je nutné nejdříve provést/napsat selekci a pak až seskupení.

A to by mělo být asi vše co se týká try. Vlastně není. Zapomněl jsem zdůraznit to, že jednotlivé bloky try lze do sebe zanořovat. Tudíž lze napsat do finally další blok try – catch.

try  {
// nějaká deklarace
}
finally  {
     // finální ošetření, ve kterém opět může nastat výjimka
     try  {
          // další deklarace
     }
     catch  (...) {
          // a její ošetření
     }
}

Příště se povídáme na vytváření vlastní výjímky a následně její vyvolání. Mimo to si ukážeme, jak by mohla vypadat reakce na výjimku. Ale také jak by v žádném případě vypadat neměla.

Obsah seriálu (více o seriálu):

Tématické zařazení:

 » Rubriky  » Java  

 

 

 

Nejčtenější články
Nejlépe hodnocené články

 

Přihlášení k mému účtu

Uživatelské jméno:

Heslo: