Programování v jazyce Java

Způsobení chyby V jazyce Java máme možnost chyby (výjimky) nejen zpracovávat, ale také je můžeme způsobovat. K vyvo...


Způsobení chyby
V jazyce Java máme možnost chyby (výjimky) nejen zpracovávat, ale také je
můžeme způsobovat. K vyvolání chyby slouží příkaz throw. Jako parametr musí být
objekt potomek třídy Throwable, který bude reprezentovat nastalou chybu.
Celé způsobení chyby může vypadat např. takto: ... throw new
FileNotFoundException();
Příkaz throw musí být buď uveden ve stráženém bloku, nebo musíme označit
metodu, která jej obsahuje. Metodu způsobující výjimku označíme klíčovým slovem
throws následovaným druhem výjimky: void mojeMetoda() throws
FileNotFoundException { ... throw new FileNotFoundException(); }
Z deklarace (a tedy také z dokumentace) k jednotlivým balíkům (knihovnám) je
potom vždy jasně patrné, které metody mohou způsobovat výjimky.
Druhy chyb
Jak již bylo uvedeno výše, všechny způsobitelné chyby jsou potomky třídy
Throwable. Tyto třídy lze dále rozdělit na tři velké skupiny potomky tříd:
Error, Exception a RuntimeException.
Třída Error a její potomci reprezentují chyby JVM. Příkladem takové chyby může
být OutOfMemoryError. Tyto chyby by v uživatelských programech asi ani neměly
být zpracovávány, protože se jedná o chyby, z nichž je velice obtížné se
zotavit.
Třída Exception a její potomci jsou standardní chyby, které uživatel vyvolává a
ošetřuje. Na tyto výjimky se v plné míře vztahuje ustanovení předchozího
odstavce o tom, že musí být buď chyceny, nebo deklarovány příkazem throws.
Třída RuntimeException, přestože je potomkem třídy Exception, má jednu
zvláštnost výjimky tohoto druhu
nemusí být deklarovány. Do této kategorie spadají totiž běžné výjimky
NullPointerException, ArrayIndexOutOfBoundsException a podobně, které by musely
být deklarovány prakticky u všech metod.
Definování vlastních výjimek
Pokud naše metoda způsobuje nějaký nový druh chyby, můžeme si vytvořit vlastní
druh výjimky. Tento postup je naprosto běžný. Stačí vytvořit potomka třídy
Exception:
class MojeException extends Exception { public MojeException() { } public
MojeException(String what) { super(what); // parametr popisující // chybu }
}
Máme-li nový druh chyby deklarován, můžeme jej použít podobně jako již
existující výjimky: throw new MojeException();
Vytváření vlastních výjimek je doporučený postup při psaní metod, které mohou
skončit neúspěchem. Příkladem může být neexistence souboru, nemožnost navázat
síťové spojení apod. Ve všech těchto případech se hodí použití mechanismu
výjimek.
Abstraktní třídy
Výhodnou vlastností objektové knihovny je možnost použití tzv. abstraktních
tříd. Jsou to třídy, které obsahují rozsáhlý kód, ale k jejichž zdárnému
fungování něco chybí. To něco je třeba doplnit v potomcích takové třídy.
Abstraktní třída obsahuje jednu nebo více abstraktních metod, tj. metod, které
nemají uveden kód. Abstraktní metody se mohou vyskytovat pouze v abstraktní
třídě:
abstract class MojeAbstraktni { abstract void fce(); void pracuj() { ... fce();
// volání abstraktní metody }
}
Pokud chceme vytvořit potomka uvedené třídy, musíme v něm dodat (implementovat)
kód všech abstraktních metod:
class Konkretni extends MojeAbstraktni { void fce() { // deklarace musí být
stejná jako // v abstraktní metodě
// implementace fce }
} ... // na jiném místě v kódu Konkretni x = new Konkretni(); x.pracuj();//
volá pracuj zděděnou // od MojeAbstraktni
// z pracuj se volá fce
// definovaná v Konkretni
Nyní je třeba odpovědět na otázku, k čemu nám může být použití abstraktních
tříd a metod dobré. Při psaní knihovny autor často potřebuje pracovat s
proměnnými nějaké třídy, kterou uživatel knihovny bude upravovat podle svého.
Autor knihovny tedy nadeklaruje abstraktní třídu a napíše v ní všechny metody,
které může napsat on. Metody, u nichž nezná jejich implementaci, protože tu
bude vytvářet uživatel knihovny, pouze deklaruje a označí jako abstraktní. To
mu však nebrání tyto abstraktní metody ve svém kódu volat. Při jejich skutečném
volání bude příslušná proměnná ukazovat na konkrétní objekt, který bude mít
všechny metody definovány.
Interface
Jedním z posledních rysů jazyka Java, se kterým se seznámíme, je použití tzv.
interfaců.Je trochu podobné použití abstraktních tříd opět se používají jako
rozhraní knihovny. Pokud chceme mít toto rozhraní ještě flexibilnější než při
použití abstraktních tříd, můžeme právě deklarovat interface. Interface je
vlastně množina deklarací metod a konstant:
public interface Rozhrani { public void f1(); public int f2(int param1);
}
Pokud máme interface definován, můžeme deklarovat proměnné tohoto typu a
používat je ve svém kódu: ... void mojeMetoda(Rozhrani x) { x.f1(); int k =
x.f2(10); ... }
Proměnné s typem rozhraní jsou z hlediska jazyka obyčejné proměnné typu odkazu
na nějaký objekt. Při volání metody používající proměnnou typu rozhraní musíme
za hodnotu této proměnné dosadit odkaz na objekt, který tzv. implementuje
uvedené rozhraní. To, že nějaká třída implementuje rozhraní, je uvedeno v její
deklaraci:
class A implements Rozhrani { ... public void f1() { ... } // deklarace
odpovídající Rozhrani public int f2(int param1) { ... }
} ... A y = new A(); // vytvoření objektu, který
// implementuje rozhraní mojeMetoda(y); // dosazení příslušného objektu
// do proměnné x
Pokud naše třída implementuje rozhraní, musí obsahovat všechny metody uvedené v
daném rozhraní. Tato vlastnost umožní fungování kódu, ve kterém se vyskytovaly
proměnné typu rozhraní. Výhodou rozhraní oproti dědění z abstraktní metody je
to, že za klíčovým slovem implements může být libovolný počet interfaců dědění
od abstraktní třídy je omezeno pouze na jednoho rodiče.
Práce s grafickým uživatelským rozhraním (GUI)
Standardní knihovny jazyka Java obsahují několik balíků pro práci s GUI.
Všechny tyto knihovny jsou napsány tak, že jednou napsaný program by měl běžet
stejně v prostředí MS Windows, Xwindows a ve všech systémech podporujících
nějakým způsobem práci s okénky. To znamená, že podpora pro grafiku musí být
integrální součástí JVM (Java Virtual Machine). Hlavní třídy jsou obsaženy v
balíku java.awt.
AWT Abstract Window Toolkit
Tato knihovna obsahuje všechny důležité třídy pro práci s uživatelským
rozhraním. Skládá se jednak z několika abstraktních tříd, které nám umožňují
vytvářet vlastní elementy uživatelského rozhraní. Velmi důležitou částí jsou
naprogramované všechny základní elementy uživatelského rozhraní. Tyto elementy
můžeme pak velice jednoduchým způsobem používat ve svých programech.
Rozhraní AWT prodělalo řadu změn od verze 1.0 do verze 1.1. V tomto seriálu si
zkusíme představit rysy, které jsou společné všem verzím, další diskuse
ponecháme na specializované pojednání.
Použití již hotových komponent uživatelského rozhraní je velice jednoduché tyto
komponenty stačí přidávat do svého programu pomocí příkazu add:
import java.awt.*;
import java.applet.*;
public class Test extends Applet{ Button okButton = new Button("OK"); Checkbox
c = new Checkbox("Skrt"); TextField t = new TextField(15); public void init() {
add(okButton); add(c); add(t); }
}
Tento příklad přidá do appletu tlačítko (Button), zaškrtávací políčko
(Checkbox) a vstupní řádku (TextField). Po přeložení, vložení do HTML dokumentu
a spuštění se v appletu objeví přidané komponenty.
V knihovně AWT najdeme několik abstraktních tříd, od nichž jsou odvozeny
všechny třídy reprezentující konkrétní elementy GUI. Základní třída se jmenuje
Component. Tato třída reprezentuje nejjednodušší komponentu, která se může
zobrazovat tj. mezi její vlastnosti patří souřadnice umístění, velikost apod.
Mezi potomky třídy Component patří:
Button reprezentuje tlačítko
Checkbox zaškrtávací políčko
List seznam s výběrem
Choice řádka s výběrem prvků
TextField vstupní řádka
TextArea editační plocha (víceřádkový vstup textu)
Label popiska
Použití těchto komponent bylo ilustrováno na uvedeném příkladu. To znamená, že
nejprve je třeba pomocí volání new a konstruktoru vytvořit příslušnou
komponentu. Tuto lze pak vložit příkazem add do tzv. kontejneru, neboli
komponenty, která může obsahovat další komponenty. Toto vložení musíme provést
před začátkem provádění programu metoda init v appletu se provede před tím, než
je applet zobrazen.
Kontejner je reprezentován objektem, který je potomkem třídy Container. Třída
Container je rovněž potomkem třídy Component. Třída Applet je potomkem třídy
Container, tj. applet je vždy kontejner, do kterého můžeme vkládat jednotlivé
komponenty pomocí metody add. Metoda add je definována ve třídě Container a
všechny její potomci ji dědí.
Píšeme-li applet, můžeme přidávat komponenty přímo do něj. Pokud však píšeme
samostatnou aplikaci, je potřeba nejprve vytvořit okno, které bude tvořit
hlavní okno našeho rozhraní. K tomuto účelu obsahuje knihovna AWT třídu Frame.
Tato třída slouží k vytváření dalších oken na obrazovce. Objekt třídy Frame je
rovněž potomkem Containeru, tj. umožňuje nám do něj vkládat komponenty podobně
jako do appletu. Chceme-li v samostatné aplikaci vytvořit nové okno, můžeme
napsat do metody main např. toto:
public static void main(String[] args) { Frame f = new Frame(); f.add(new
Button("Ok")); f.show();
}
V tomto případě jsme vyvolali metodu add na objekty třídy Frame. Po zavolání
metody show uvidíme na obrazovce nové okénko s jedním tlačítkem. Tento program
nereaguje na žádné události, dokonce ani na pokus o zavření okna. Pokud chceme,
aby program něco dělal, musíme přidat ještě reakce na tvz. události.
7 3349 / pah









Komentáře
K tomuto článku není připojena žádná diskuze, nebo byla zakázána.