Obsługa zdarzeń - Przyciski

Poznaliśmy bardzo podstawowy schemat tworzenia aplikacji graficznych w języku Java. Wiemy jak narysować proste kształty, jak dodać przyciski i mniej więcej na czym polegają zarządcy rozkładu. Od naszego programu oczekujemy jednak zapewne czegoś więcej niż tylko przycisków, które nic nie robią i możliwości narysowania kilku kwadracików, z którymi także nic nie da się zrobić. W bibliotece AWT istnieje jednak bardzo przyjemny mechanizm obsługi zdarzeń, który pozwoli nam pisać programy odpowiadające na czynności wykonywane przez użytkownika.

Zdarzenia generowane podczas działania programów pozwolą nam między innymi na:

• obsługę wciśnięcia przycisku

• możliwość odczytywania położenia kursora

• odczytywania jaki przycisk został wciśnięty na klawiaturze, lub myszy

• i wiele innych rzeczy, które można sobie wyobrazić w programie

W naszej aplikacji napisanej w Javie musimy stworzyć w tym celu kilka rzeczy. Nie wystarczy wywołać jakiejś metody na rzecz konkretnego obiektu (na przykład przycisku), bo przecież musimy wiedzieć, że ten przycisk może być wciśnięty, musimy też wiedzieć, co ma się stać, gdy to nastąpi. Pierwszym krokiem będzie więc utworzenie słuchacza , czyli obiektu klasy implementującej interfejs ActionListener. Najprostsza z możliwych klas przycisku, który pozwoli nam na jakiekolwiek działanie będzie więc wyglądała tak:

import java.awt.event.ActionEvent;
 import java.awt.event.ActionListener;
 
 import javax.swing.JButton;
 
 public class Przycisk extends JButton implements ActionListener{
 	@Override
 	public void actionPerformed(ActionEvent arg0) {
 		// TODO Auto-generated method stub
 	}
 }

Jak widać w związku z implementowaniem interfejsu ActionListener musieliśmy również utworzyć metodę actionPerformed(). Przyjmuje ona jakiś parametr, jednak skąd go wziąć i jak taką metodę wywołać? No więc najciekawsze jest to, że my w zasadzie nie musimy się tym przejmować. Metoda ta jest wywoływana, kiedy zostanie wygenerowane zdarzenie na obiekcie powiązanym z danym słuchaczem. Może to być przycisk, pole tekstowe, checkbox, czy suwak. Przekazywany argument ActionEvent przechowuje wiele informacji w tym źródło, które możemy pobrać przy pomocy metody getSource(). Żeby zobaczyć to na jakimś życiowym przykładzie poniżej zamieszczono klasy programu, który zmienia tło po wciśnięciu jednego z trzech przycisków.

import java.awt.*;
 import java.awt.event.ActionEvent;
 import java.awt.event.ActionListener;
 
 import javax.swing.JButton;
 import javax.swing.JPanel;
 
 public class ButtonPanel extends JPanel implements ActionListener{
 
 	public static final int HEIGHT = 100;
 	public static final int WIDTH = 300;
 	private JButton greenButton;
 	private JButton blueButton;
 	private JButton redButton;
 
 	public ButtonPanel() {
 		greenButton = new JButton("Green");
 		blueButton = new JButton("Blue");
 		redButton = new JButton("Red");
 
 		greenButton.addActionListener(this);
 		blueButton.addActionListener(this);
 		redButton.addActionListener(this);
 
 		setLayout(new FlowLayout());
 		setPreferredSize(new Dimension(WIDTH, HEIGHT));
 		add(greenButton);
 		add(blueButton);
 		add(redButton);
 	}
 
 	@Override
 	public void actionPerformed(ActionEvent e) {
 		Object source = e.getSource();
 
 		if(source == greenButton)
 			setBackground(Color.GREEN);
 
 		else if(source == blueButton)
 			setBackground(Color.BLUE);
 
 		else if(source == redButton)
 			setBackground(Color.RED);
 	}
 }

import javax.swing.*;
 
 public class ActionFrame extends JFrame {
 
 	public ActionFrame() {
 		super("Test akcji");
 
 		JPanel buttonPanel = new ButtonPanel();
 		add(buttonPanel);
 
 		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 		pack();
 		setVisible(true);
 	}
 }

import java.awt.EventQueue;
 
 class Test {
 	public static void main(String[] args) {
 		EventQueue.invokeLater(new Runnable() {
 			@Override
 			public void run() {
 				new ActionFrame();
 			}
 		});
 	}
 }

Jak widać ciekawa jest tylko pierwsza klasa, w drugiej i trzeciej nie odnajdujemy nic nowego. Co więc się kolejno dzieje. Utworzyliśmy dwie stałe oznaczające wysokość i szerokość naszego panelu, a także trzy przyciski, odpowiedzialne odpowiednio za zmianę koloru na, zielony(greenButton), niebieski(blueButton) i czerwony(redButton). Jak widać rozwiązanie jest jednak nieco inne niż prezentowane na początku lekcji. Tym razem słuchaczem jest cały kontener komponentów (w naszym przypadku panel, a może nim być także obiekt JComponent, czy nawet ramka dziedzicząca po klasie JFrame), natomiast źródłami trzy przyciski. Dzięki dodaniu słuchacza do każdego z przycisków (w naszym przypadku słuchaczem jest panel, więc przekazujemy this):

	greenButton.addActionListener(this);
 	blueButton.addActionListener(this);
 	redButton.addActionListener(this);

nasz panel będzie teraz powiadamiany za każdym razem kiedy będzie wciśnięty jeden z przycisków i zostanie wtedy wywołana jego metoda actionPerformed(). Można sobie to najprościej wyobrazić jako krótką konwersację:

-Ej wy przyciski, wiem, że możecie być wciskane i powiadamiać o tym innych

-Jasne podaj nam tylko jakiś obiekt implementujący interfejs ActionListener, a gdy ktoś nas wciśnie to damy mu znać. Oczywiście może być ich wiele, wystarczy, że kilka razy wywołasz naszą metodę addActionListener()

-Ok przekazuję wam więc referencję klasy ButtonPanel, w której się znajdujecie. Ona będzie wiedziała co ma dalej robić, bo przeciążyłem w niej metodę actionPerformed().

W tej z kolei sprawdzamy źródło zdarzenia, pobrane metodą getSource() otrzymanego argumentu ActionEvent. Jak widać wystarczyło nam zwykłe porównanie za pomocą ==, ponieważ interesuje nas referencja, a nie to co obiekt przechowuje. Nie dalej nic innego jak zmiana koloru panelu poprzez wywołanie metody setBackground() z odpowiednią stałą koloru Color.GREEN, Color,BLUE, albo Color.RED.

Można by się zastanowić, czy nie da się w naszym przypadku całkowicie odłączyć przycisków od naszej klasy panelu. Oczywiście, że się da, jednak w tak prostym przykładzie nieco mija się to z celem. Wiąże się to, albo z utworzeniem klasy wewnętrznej do każdego przycisku, lub nawet klas zewnętrznych, którym i tak musimy przekazać wtedy referencję do panelu. Poniżej zamieszczona jest klasa panelu, który wykorzystuje rozwiązanie z klasami wewnętrznymi (działanie jest identyczne, jak programu powyżej):

import java.awt.*;
 import java.awt.event.ActionEvent;
 import java.awt.event.ActionListener;
 
 import javax.swing.JButton;
 import javax.swing.JPanel;
 
 public class ButtonPanel extends JPanel{
 
 	public static final int HEIGHT = 100;
 	public static final int WIDTH = 300;
 	private JButton greenButton;
 	private JButton blueButton;
 	private JButton redButton;
 
 	private JPanel buttonPanel;
 
 	public ButtonPanel() {
 		greenButton = new GreenButton();
 		blueButton = new BlueButton();
 		redButton = new RedButton();
 
 		buttonPanel = this;
 
 		setLayout(new FlowLayout());
 		setPreferredSize(new Dimension(WIDTH, HEIGHT));
 		add(greenButton);
 		add(blueButton);
 		add(redButton);
 	}
 
 	class GreenButton extends JButton implements ActionListener {
 
 		GreenButton() {
 			super("Green");
 			addActionListener(this);
 		}
 
 		@Override
 		public void actionPerformed(ActionEvent e) {
 			buttonPanel.setBackground(Color.GREEN);
 		}
 	}
 
 	class BlueButton extends JButton implements ActionListener {
 
 		BlueButton() {
 			super("Blue");
 			addActionListener(this);
 		}
 
 		@Override
 		public void actionPerformed(ActionEvent e) {
 			buttonPanel.setBackground(Color.BLUE);
 		}
 	}
 
 	class RedButton extends JButton implements ActionListener {
 
 		RedButton() {
 			super("Red");
 			addActionListener(this);
 		}
 
 		@Override
 		public void actionPerformed(ActionEvent e) {
 			buttonPanel.setBackground(Color.RED);
 		}
 	}
 
 }