AlgorytmyTurbo PascalC++JavaTypy danychOperatoryInstrukcjeKlasy i obiektyMetody i polaMetody specjalneInterfejsyPakietyWyjątkiKurs JavyNarzędziaPierwszy programOpis językaTypy danych i zmienneOperatoryInstrukcjeKlasy i obiektyObsługa wyjątkówPrzykłady programówApletyPierwszy appletRysowanieAnimacjaZdarzeniaPrzykładowe apletyAplikacje okienkoweOkno i menuKomponentyOperacje na plikachPrzykładZadaniaVisual Basic 6 Aplikacje internetowe MySQL Excel DOS

Część 5.1. Okno i menu

Tworzenie okna

Działanie takiej aplikacji rozpoczyna się - jak zwykłych programów - od metody main. Metoda ta musi stworzyć nowy obiekt własnej klasy, wstawić lub wyrysować w nim wszystkie potrzebne elementy, a następnie wyświetlić. W oknie możemy używać wszystkich metod graficznych poznanych przy nauce tworzenia apletów. Możemy też wstawiać obiekty reagujące na działania użytkownika, a znane z każdej niemal aplikacji okienkowej: etykiet, pola tekstowe, listy, pola wyboru i opcji, przyciski poleceń.

Podstawową klasą służącą do tworzenia aplikacji okienkowych jest Frame: klasa tworząca pojemnik, w którym pracuje program. W niej rozmieszczamy wszystkie elementy graficzne i kontrolne. Wszystkie programy okienkowe muszą po niej dziedziczyć.

Aby okno mogło reagować na zdarzenia, nasza aplikacja musi zaimplementować interfejs WindowListener. Jest on niezbędny choćby do poprawnego zamknięcia okna. Ponieważ interfejs wymaga zdefiniowania wszystkich jego metod, to będziemy musieli to zrobić w naszym programie, choćby miały one być puste. Poniższa tabela podaje listę wszystkich metod interfejsu WindowListener, które musimy zadeklarować w naszym programie:

metoda	wykonywana:
windowClosing	kiedy okno jest zamykane
windowClosed	po zamknięciu okna
windowOpened	po otwarciu okna
windowIconified	po minimalizacji okna
windowDeiconified	po maksymalizacji okna
windowActivated	po aktywowaniu okna
windowDeactivated	gdy okno przestaje być aktywne

Napiszemy teraz pierwszy program okienkowy. Utworzymy nowe okno, umieścimy w nim napis oraz przycisk służący do zakończenia pracy programu (dokładniej przyciski poleceń omówimy w następnej części kursu). Okno będzie czekać na wciśnięcie przycisku i wtedy zakończy pracę. Oto kod tego programu:

import java.awt.*;
import java.awt.event.*;

public class HelloApp extends Frame implements WindowListener, ActionListener
{ // deklaracja obiektu przycisk polecenia
  Button button;

  // konstruktor naszej klasy
  public HelloApp ()
  { // wywołanie konstruktora klasy Frame
    super ( );
    // zarejestrowanie obsługi zdarzeń związanych z oknem
    addWindowListener(this);
    // zdefiniowanie rozmiarów okna
    setSize(320, 200);
    // nadanie tytułu okna
    setTitle("Moja aplikacja w Javie");
    // ustawienie "ręcznego" rozmieszczania elementów okna
    setLayout(null);

    // utworzenie przycisku z tekstem OK
	button = new Button("OK");
    // zdefiniowanie jego położenia i wielkości
    button.setBounds(135, 90, 50, 20);
    // zgłoszenie obsługi zdarzeń dla przycisku
    button.addActionListener(this);
    // dodanie przycisku do okna
    add(button);

    // wyświetlenie okna aplikacji
    setVisible(true);
  }

  // obsługa kliknięcia przycisku: zakończenie programu
  public void actionPerformed (ActionEvent e)
  { String command = e.getActionCommand();
    if (command.equals("OK"))	System.exit(0);
  }

  // wyświetlenie tekstu w okienku programu
  public void paint(Graphics g)
  { g.drawString("To jest aplikacja okienkowa",100,50);
  }

  // metoda main, od której zaczyna się wykonanie programu
  // jedyną jej funkcją jest wywołanie własnego konstruktora klasy
  public static void main(String args[])
  { new HelloApp ( );
  }

  // definicja metod interfejsu WindowListener
  // zwróć uwagę, że kod istnieje tylko dla zamknięcia okna
  public void windowClosing     (WindowEvent e)  { System.exit(0); }
  public void windowClosed      (WindowEvent e)  {   }
  public void windowOpened      (WindowEvent e)  {   }
  public void windowIconified   (WindowEvent e)  {   }
  public void windowDeiconified (WindowEvent e)  {   }
  public void windowActivated   (WindowEvent e)  {   }
  public void windowDeactivated (oWindwEvent e)  {   }
}

Po napisaniu programu należy go skompilować i uruchomić. Efekt powinien wyglądać tak:

Tworzenie menu

Każdy niemal program, który uruchamiałeś posiada jakieś menu. Kolejnym krokiem w naszym programie będzie stworzenie prostego menu programu. Menu główne będzie posiadało dwie opcje: do zmiany wielkości okna programu oraz do jego zakończenia. Damy możliwość wyboru przez użytkownika wielkości okna programu w kilku wybranych wielkościach. Zakończenie aplikacji będzie również możliwe z menu.

Stworzenie menu wymaga użycia 2 klas: klasy MenuBar, która tworzy listwę menu oraz klasy Menu, która zawiera opcje programu. Obiektów klasy Menu możemy tworzyć wiele i kolejno dokładać je do wcześniej utworzonej listwy MenuBar.

Jednak oprócz utworzenia samego menu musimy je jeszcze w programie obsłużyć. Wymaga to zaimplementowania w naszej aplikacji interfejsu ActionListener. To z kolei zmusza nas do zdefiniowania jedynej metody tej klasy actionPerformed. Metoda te jest zawsze wywoływana po wybraniu przez użytkownika którejkolwiek z opcji menu aplikacji i jej zadaniem jest rozpoznanie wybranej opcji i jej obsłużenie.

Wiedząc już to wszystko przystępujemy do napisania naszego programu:

import java.awt.*;
import java.awt.event.*;

public class WindowAndMenu extends Frame implements WindowListener, ActionListener
{ public WindowAndMenu ()
  { super ( );
    addWindowListener(this);
    setSize(300, 200);
    setTitle("Pierwsza aplikacja w Javie");
    setLayout(null);

    // tworzymy listwę menu aplikacji
    MenuBar menuBar = new MenuBar();
    setMenuBar(menuBar);

    // tworzymy nową pozycję menu
    Menu menu = new Menu("Rozmiar okna");
    // do utworzonej pozycji dodajemy opcje
    menu.add(new MenuItem("300 x 300"));
    menu.add(new MenuItem("300 x 400"));
    menu.add(new MenuItem("300 x 500"));
    menu.add(new MenuItem("-"));
    menu.add(new MenuItem("400 x 300"));
    menu.add(new MenuItem("400 x 400"));
    menu.add(new MenuItem("400 x 500"));
    menu.add(new MenuItem("-"));
    menu.add(new MenuItem("500 x 300"));
    menu.add(new MenuItem("500 x 400"));
    menu.add(new MenuItem("500 x 500"));
    // dodajemy pozycje do listwy menu
    menuBar.add(menu);
    // rejestrujemy obsługę zdarzeń menu
    menu.addActionListener(this);

    // tworzymy nową pozycję menu
    menu = new Menu("Koniec");
    // do utworzonej pozycji dodajemy opcje
    menu.add(new MenuItem("Zamknij"));
    // dodajemy pozycje do listwy menu
    menuBar.add(menu);
    // rejestrujemy obsługę zdarzeń menu
    menu.addActionListener(this);

    // wyświetlamy okno aplikacji
    setVisible(true);
 }

  // definicja metod interfejsu ActionListener
  // odpowiedzialnego za obsługę wszystkich opcji menu
  public void actionPerformed (ActionEvent e)
  { // pobranie tekstu wybranej opcji
    String sCommand = e.getActionCommand();

    // pobranie 1-szego znaku tekstu opcji
    String iWidth   = sCommand.substring(0, 1);
    // pobranie 7-szego znaku tekstu opcji
    String iHeight  = sCommand.substring(6, 7);

    // jeżeli wybrany Zamknij, to zakończenie programu
    if (sCommand.equals("Zamknij")) { System.exit(0);            }

    // ustawienie szerokości okna zgodnie z wybraną wielkością 
    if (iWidth.equals("3"))         { setSize(300, getHeight()); }
    else if(iWidth.equals("4"))     { setSize(400, getHeight()); }
    else if(iWidth.equals("5"))     { setSize(500, getHeight()); }

    // ustawienie wysokości okna zgodnie z wybraną wielkością 
    if (iHeight.equals("3"))        { setSize(getWidth(), 300);  }
    else if (iHeight.equals("4"))   { setSize(getWidth(), 400);  }
    else if (iHeight.equals("5"))   { setSize(getWidth(), 500);  }
  }

  // metoda main, od której zaczyna się wykonanie programu
  // jedyną jej funkcją jest wywołanie własnego konstruktora klasy
  public static void main(String args[])
  {
     new WindowAndMenu();
  }

  // definicja metod interfejsu WindowListener
  public void windowClosing    (WindowEvent e) { System.exit(0); }
  public void windowClosed     (WindowEvent e) {   }
  public void windowOpened     (WindowEvent e) {   }
  public void windowIconified  (WindowEvent e) {   }
  public void windowDeiconified(WindowEvent e) {   }
  public void windowActivated  (WindowEvent e) {   }
  public void windowDeactivated(WindowEvent e) {   }
}

Teraz należy program skompilować i uruchomić. Możesz sprawdzić, jak zmienia się wielkość okna w zależności od wybranej opcji z menu. Tak wygląda przykładowe okno: