W tym celu w deklaracji klasy zmieniamy nazwę Frame na Jframe, czyli
public class naszaKlasa extends Frame
na
public class naszaKlasa extends JFrame
Teraz zajmiemy się zmienieniem naszych komponentów na „jkomponenty”. Jak to zrobić? Do każdego z zadeklarowanych komponentów interfejsu, na początku ich nazwy powinniśmy dodać literkę „J”. Ale to nie wszystko. Zmiana nazwy w deklaracji komponentu, wymusi również zmiany w nazewnictwie komponentów znajdujących się konstruktorze klasy, oraz zmianę metod klas poszczególnych nowych komponentów. Poniżej przedstawię schematycznie jak wygląda zmiana typu komponentu:
przycisk = new JButton(“Oblicz”);
przycisk.setBounds(390,40,100,20);
przycisk.addActionListener(this);
add(przycisk);
Powyżej napisałem przykładową instancję przycisku. Zmiana nastąpiła w nazwie klasy komponentu (JButton). Oczywiście możemy dodatkowo uatrakcyjnić wygląd przycisku, dodając w konstruktorze ikonę, która będzie widoczna na przycisku za napisem „Oblicz”. Można to zrobić tak:
przycisk = new Jbutton(“Oblicz”, new ImageIcon(„ikona.jpg”));
przycisk.setBounds(390,40,100,20);
przycisk.addActionListener(this);
add(przycisk);
Lokalizacja pliku graficznego “ikona.jpg” w katalogu projektu
Jak widać na screenie plik graficzny umieszczamy w katalogu projektu, lub w dowolnie wybranym miejscu na dysku komputera do którego mamy odpowiednie uprawnienia. Wystarczy w konstruktorze przycisku podać ścieżkę do położenia pliku.
Proponuję również aby komponent „List” zmienić na „JComboBox”. ”JComboBox” to nic innego jak lista rozwijana. Charakteryzuje się tym, iż obsługuj nieco inne metody niż komponent „List”. Wszystkie dostępne metody i właściwości „JComboBox”, można znaleźć w dokumentacji dostępnej na stronie: http://java.sun.com/j2se/1.4.2/docs/api
Zastosujemy zatem zmiany w konstruktorze klasy:
lista = new JComboBox();
lista.setBounds(500,40,100,20);
lista.addItem(“Dodawanie”);
lista.addItem(“Odejmowanie”);
lista.addItem(“Mnożenie”);
lista.addItem(“Dzielenie”);
kontener.add(lista);
Zmieni się również kod metody „wstawdanezoperacjidoOkna”, na:
public void wstawdanezoperacjidoOkna()
{
String liczba1,liczba2,wynik;
String rodzajOperacji;
String znakoperacji = “”;
rodzajOperacji = (String)lista.getSelectedItem(); // Zmiana metody
liczba1 = pole1.getText();
liczba2 = pole2.getText();
wynik = pole3.getText();
if(rodzajOperacji.equals(“Dodawanie”))
{
znakoperacji = “+”;
}
if(rodzajOperacji.equals(“Odejmowanie”));
{
znakoperacji = “-“;
}
if(rodzajOperacji.equals(“Mnożenie”));
{
znakoperacji = “*”;
}
if(rodzajOperacji.equals(“Dzielenie”));
{
znakoperacji = “/”;
}
okno.append(rodzajOperacji + ” : ” + liczba1 + ” ” + znakoperacji + ” ” + liczba2 + ” = ” + wynik + ” “); // zmiana metody
}
Łatwo zauważyć zatem, że kod metody uległ tylko małej modyfikacji. Zmienił się sposób pobrania pozycji z listy typu „JComboBox”. Element pobierany jest typu „Object” i zostaje skonwertowany na typ „String” a następnie przypisany zmiennej „rodzajOperacji”. To pierwsza zmiana. Druga zmiana jest mniejsza i dotyczy znaku nowej linii „/n” na końcu metody „append”. Tak aby każde z kolejnych obliczeń było dodawane do okna w nowym wierszu. Jak widać niewielkie zmiany w wyglądzie aplikacji skutkują również zmianami w kodzie metod.
Idąć dalej proponuję rozbudować menu o kolejną pozycję. Będzie to „Edycja”. „Edycja” do której dodamy podstawowe metody edycyjne dostępne dla okna tekstowego aplikacji. Będą to metody:
Zaznacz wszystko
Wytnij
Skopiuj
Wklej
A zatem inicjujemy nową pozycję menu i jego pozycje w deklaracji klasy:
JMenu plik, edycja;
JMenuItem zaznaczWszystko,wytnij, kopiuj, wklej;
A w konstruktorze tworzymy nowe obiekty menu, oczywiście dodając je od razu do interfejsu nasłuchującego „ActionListener” oraz do powierzchni okna:
zaznaczWszystko = new JMenuItem(“Zaznacz wszystko”);
zaznaczWszystko.addActionListener(this);
edycja.add(zaznaczWszystko);
wytnij = new JMenuItem(“Wytnij”);
wytnij.addActionListener(this);
edycja.add(wytnij);
kopiuj = new JMenuItem(“Kopiuj”);
kopiuj.addActionListener(this);
edycja.add(kopiuj);
wklej = new JMenuItem(“Wklej”);
wklej.addActionListener(this);
edycja.add(wklej);
Menu “Edycja” z rozwiniętymi pozycjami
owe menu w pełnej okazałości. Teraz zajmijmy się oprogramowaniem nowych metod. Metody te są proste w stosowaniu. Po prostu działają jak schowek systemowy. Zobaczmy jak można oprogramować wszystkie przedstawione metody edycyjne dla naszego „okna”. W metodzie „actionPerformed”, wystarczy umieścić taki kod:
if(e.getSource() == zaznacz)
{
okno.selectAll();
}
if(e.getSource() == wytnij)
{
okno.cut();
}
if(e.getSource() == kopiuj)
{
okno.copy();
}
if(e.getSource() == wklej)
{
okno.paste();
}
Jak widać jest to bardzo proste, a pozwala na wykonywanie podstawowych czynności edycyjnych dla pola tekstowego, oraz uatrakcyjnia naszą całą aplikację.
Cóż znaczy aplikacja, bez możliwości zapisu lub odczytu danych z dysku komputera? Odpowiedź brzmi – mało. Jak obiecałem w poprzedniej części artykułu, pokażę teraz jak oprogramować metody zapisu na dysk i odczytu pliku z dysku komputera.
Wybierając z menu „Plik” pozycję „Zapisz do pliku”, powinniśmy mieć na początku możliwość wyboru lokalizacji dla zapisywanych danych. Dlatego posłużymy się oknem wyboru plików „JFileChooser”. Jak sama nazwa wskazuje okno pozwoli nam na swobodną nawigację po systemie plików. Deklaracja wygląda tak:
JFileChooser oknoPliku;
Napiszmy zatem metodę, która pozwoli zapisać nam na dysku komputera wyniki obliczeń.
public void zapisz()
{
File plik = new File(oknoPliku.getSelectedFile() + “.txt”);
try
{
String tekst = okno.getText();
FileOutputStream fos = new FileOutputStream(plik);
byte [] bufor = tekst.getBytes();
fos.write(bufor,0,bufor.length);
fos.close();
JOptionPane.showMessageDialog(null,”Zapisałem dane do pliku!”,”Zapis do pliku”,1);
okno.setText(“”);
}
catch(Exception e)
{
JOptionPane.showMessageDialog(null,”Nie mogę zapisać pliku!”,”Zapis do pliku”,0);
}
}
Przyglądając się metodzie „zapisz”, widać, że najpierw trzeba utworzyć obiekt klasy „File”, w konstruktorze którego umieszczamy tak naprawdę, nazwę nowego pliku wybranego w „okniePliku” z rozszerzeniem „txt”. Deklarujemy zmienną typu „String” i za pomocą „getText”, przypisujemy jej zawartość „okna”.
Dalej tworzymy tzw „strumień”, w konstruktorze którego umieścimy utworzony przed chwilą obiekt „plik”. Deklarujemy tablicę typu „byte” o nazwie „bufor” do której niejako „załadujemy” bajt po bajcie cały tekst z okna za pomocą metody „getBytes”.
Korzystając z wcześniej utworzonego obiektu „fos” i jego metody „write”, zapiszemy do pliku wszystkie dane. Zapis będzie trwał od miejsca 0 w buforze do momentu aż bufor nie osiągnie ostatniego bajtu(metoda „length” dla tablicy „bufor”). Kiedy operacja zapisu dobiegnie końca, zamykamy strumień „fos”, przy użyciu metody „close”. Oraz informujemy komunikatem o udanej operacji zapisu do pliku.
Oczywiście całość kodu jest ujęta w blok „try – catch”, aby obsłużyć ewentualny błąd zapisu. Aby dobrze zrozumieć istotę zapisu i odczytu danych z pliku polecam, zapoznanie się z jednym z wielu opracowań dotyczących języka Java, dostępnych w wielu księgarniach informatycznych oraz z dokumentacją języka.
Kolejna metoda naszej aplikacji to metoda „odczyt”. Metoda odczytu danych z pliku będzie wyglądać nieco inaczej niż zapis danych:
public void odczytaj()
{
BufferedReader brIn = null;
try{
brIn = new BufferedReader(new FileReader(oknoPliku.getSelectedFile().getAbsolutePath()));
String tekst = “”;
while((tekst = brIn.readLine()) != null)
{
okno.append(tekst + ” “);
}
brIn.close();
}
catch(Exception e)
{
JOptionPane.showMessageDialog(null,”Nie mogę wczytać pliku!”,”Wczytywanie pliku”,0);
}
}
W metodzie tej najpierw tworzony jest obiekt „BufferedReader”, posłuży on do odczytu zawartości pliku w pętli „while”. W jego konstruktorze jako parametr przekazywany jest nowy obiekt klasy „FileReader”, którego parametrem jest pobrana z okna pliku, absolutna ścieżka do pliku.
Ponieważ i ta metoda może spowodować wystąpienie błędu, jest ujęta w bloku „try – catch”. Błąd może wystąpić w chwili gdy na przykład będziemy próbować wczytać usunięty wcześniej ale jeszcze widoczny plik, lub ścieżka do pliku będzie nie istnieć.
Deklarujemy zatem w metodzie zmienną „tekst”, do niej będą wczytywane dane w pętli przy użyciu metody „readLine” obiektu „brIn”. Po wczytaniu danych do zmiennej „tekst”, strumień wejściowy „brIn” jest zamykany metodą „close”.
I oto nasza cała metoda odczytująca dane z pliku, które będziemy mogli obejrzeć po wczytaniu do okna aplikacji. Jak poprzednio, zachęcam czytelników do przeanalizowania „krok po kroku”, metody tak aby zrozumieć sens jej działania.
Okno wyboru plików “Otwórz plik”
Aby uruchomić metody „odczyt” i „zapisz”, musimy je związać ze zdarzeniem i obsłużyć w metodzie „actionPerformed”. Jak to zrobić? Pokażę poniżej:
if(e.getSource() == zapiszdoPliku)
{
oknoPliku = new JFileChooser();
oknoPliku.addActionListener(this);
oknoPliku.setDialogTitle(“Okno wyboru plików”);
String tekstzokna;
tekstzokna = okno.getText().trim();
if(tekstzokna.equals(“”))
{
JOptionPane.showMessageDialog(null,”Brak danych do zapisu!”,”Zapis do pliku”,0);
}
else{
oknoPliku.addChoosableFileFilter(new FiltrTxt());
int wybor = oknoPliku.showDialog(null,”Zapisz”);
if(wybor == 0){
zapisz();
}
else{
return;
}
}
}
if(e.getSource() == odczytajzPliku)
{
oknoPliku = new JFileChooser();
oknoPliku.addActionListener(this);
oknoPliku.setDialogTitle(“Okno wyboru plików”);
int wybor = oknoPliku.showDialog(null,”Otwórz”);
if(wybor == 0){
odczytaj();
}
else{
return;
}
}
Jak widać metody są uruchamiane wewnątrz metody „actionPerformed”, w odpowiedzi na zdarzenia – odpowiednio „zapiszdoPliku” i „odczytajzPliku”. Najpierw tworzy się okno wyboru plików, jest dla niego ustawiana nazwa oraz interfejs nasłuchujący , a następnie dla okna tego jest wywoływana metoda „showDialog”, zwracająca zmienną typu „Integer” w zależności od dokonanego wyboru . Zero oznacza akceptację pliku, jeden oznacza rezygnację, czyli użycie przycisku „Cancel”. Następny krok to prosty warunek „if”. Jeśli plik został wybrany to uruchamiana jest metoda „odcztaj”, jeśli nie, metoda nie robi nic. W przypadku obu metod schemat kodu jest identyczny.
Nasza aplikacja pozwala nam na wykonywanie prostych obliczeń, na podstawowe funkcje edycyjne na danych, oraz na zapisywanie i odczytywanie plików z dysku komputera. W artykule pominąłem obsługę okna wyboru plików w filtr widoku plików, ponieważ uznałem iż może to być dobry materiał do kolejnego artykułu. Jeśli artykuł cieszył się zainteresowaiem czytelników.
Na tym chciałbym zakończyć trzecią część mojego artykułu wprowadzającego do nauki programowania w Javie przy użyciu środowiska Eclipse na bazie systemu Linux. Mam nadzieję, że moja praca zainteresuje osoby, które chcą zacząć przygodę z programowaniem w środowisku Java. Powodzenia.
