Instalacja Javy i Eclipse
Aby rozpocząć przygodę z programowaniem w Eclipse musimy na początek zainstalować w naszym systemie środowisko Java. Domyślnie w większości dostępnych dystrybucji Linuksa, Java jest już zainstalowana w systemie, lecz aby upewnić się, że mamy zainstalowane najnowsze środowisko Javy w systemie powinniśmy uruchomić tzw menadżer oprogramowania(np. Synaptic), po czym za jego pomocą wyszukać pakiety Javy i sprawdzić czy są zainstalowane w systemie czy też nie. Jeśli nie mamy zainstalowanej Javy w naszym komputerze, należy zaznaczyć odpowiednie pakiety (najlepiej najnowszą wersję) i zainstalować ją. Innym sposobem na sprawdzenie oraz zainstalowanie Javy jest wyszukanie programu Eclipse i po zaznaczeniu go do instalacji, menadżer powinien samoczynnie pobrać odpowiednie środowisko Javy i zainstalować je wraz z Eclipse. Po zainstalowaniu całego potrzebnego oprogramowania możemy juz przejść do stworzenia pierwszego projektu w Eclipse.
Pierwszy projekt
Przystępujemy, zatem do utworzenia pierwszego projektu. Po uruchomieniu Eclipse, powinniśmy potwierdzić domyślną lokalizację dla naszej przestrzeni pracy (tzw. workspace). Możemy zaakceptować domyślną lokalizację w naszym katalogu domowym lub wybrać inną lokalizację na dysku gdzie będą zapisywane wszystkie projekty, jakie utworzymy w Eclipse. Po tej czynności, Eclipse powita nas stroną startową. Strona startowa narazie nas nie interesuje, więc możemy ją zamknąć klikając na krzyżyk w prawym górnym rogu widoku karty.
Aby utworzyć nowy projekt Javy, wybieramy z menu “Plik” i “Nowy”. W oknie, które pojawi się pomijamy pole tekstowe “Wizards”, a z listy projektów, która znajduje się poniżej, wybieramy “Java” i “Java project”, klikając na “Next” i w polu “Nazwa projektu” wpisujemy nazwę dla projektu np. Projekt 1.
Poczekajmy chwilę a w lewej części okna pojawi się nasz pierwszy projekt. Projekt sam w sobie nie jest jeszcze użytecznym programem, dlatego w projekcie tym powinniśmy utworzyć pierwszą klasę.
Pierwsza klasa
Wybieramy menu “Plik” i “Nowa” oraz “Class”, pojawi się okno, w którym możemy ustawić parametry naszej klasy. Poczynając od pierwszego pola, powinniśmy wybrać, jako folder źródłowy folder “src” z pierwszego projektu, następnie opuszczamy inne pola i przechodzimy do pola
“Nazwa klasy”, tutaj podajemy nazwę naszej klasy. Pamiętajmy o tym, aby nazwa naszej klasy była inna od nazwy projektu oraz nie zawierała spacji. Poniżej możemy ustawić inne parametry klasy, na początek proponuję, aby zaznaczyć opcję ustawienia metody “main”, znajduje się ona poniżej w tym samym oknie, zostanie wówczas automatycznie dodana do nowo tworzonej klasy.
W ten sposób w oknie edytora kodu Eclipse pojawi się kod pierwszej klasy w projekcie pierwszym.
Tworzenie aplikacji
Teraz już możemy przystąpić do tworzenia swojej pierwszej aplikacji w Eclipse używając do tego Javy. W oknie edytora mamy już podstawowy kod, dzięki któremu możemy uruchomić nasz program, ale to nie wszystko. Aby program wykonał jakąś operację musimy w metodzie “main” wywołać dowolną instrukcję. Niech na początek będzie to wypisanie na ekranie konsoli jakiegoś napisu. Aby tak się stało musimy wewnątrz metody „main” napisać przykładowy kod:
System.out.println (“Pierwsza aplikacja w Eclipse!”);
Eclipse kompiluje kod w locie, zatem można już uruchomić pierwszą aplikację. Teraz wystarczy kliknąć na przycisk “Run” i po chwili w oknie konsoli (poniżej okna edytora kodu) zobaczymy efekt działania naszego programu. Fajna sprawa!, udało się uruchomić pierwszy program w Eclipse!
Oczywiście program nie robi niczego użytecznego. Napiszmy, zatem kod, który będzie wykonywał jakąś operację. Niech będzie to kod, który pomnoży dwie liczby przez siebie i pokaże wynik mnożenia na ekranie.
Wewnątrz metody “main” wpiszmy kod:
double liczba1 = 2; // deklaracja zmiennej liczba1
double liczba2 = 3; // deklaracja zmiennej liczba2
double wynik = liczba1 * liczba2; // deklaracja zmiennej wynik i przypisanie jej wartości
// pomnożonych, zmiennej liczba1 i zmiennej liczba2
System.out.println(liczba1 + " * " + liczba2 + " = " + wynik); // Wyświetlenie wyniku na ekranie
Jest to bardzo prosty przykład programu, który “coś” robi. Kod składa się po kolei z deklaracji dwóch zmiennych typu zmiennoprzecinkowego (double), deklaracji zmiennej “wynik” i przypisaniu jej wartośći dwóch pomnożonych przez siebie zmiennych “liczba1” i “liczba2”,a następnie zobrazowaniu takiego wyniku na ekranie komputera używając do tego metody “println”.
Znaczki “+”, które znajdują się w nawiasach metody “println” to nic innego jak łączenie ciągów znaków (konkatenacja), potrzebna między innymi do czytelnego podania wyniku na ekran. Wynik działania programu powinien wyglądać tak: 2.0 * 3.0 = 6.0. Oczywiście jest to tylko jeden z wielu sposobów wykonania takiego programu. Można zadać sobie pytanie. Co się stanie, jeżeli jedna ze zmiennych będzie zerem?
Otórz Eclipse wygeneruje “wyjątek”. Ale tematem wyjątków zajmę się w następnym artykule o programowaniu w Javie. Programik rozwinę w następnej części, gdzie opiszę jak stworzyć aplikację okienkową.
Tworzenie aplikacji okienkowej
Tworzenie aplikacji okienkowej wgląda nieco inaczej niż w poprzednim przypadku. Na samym początku musimy stworzyć okienko aplikacji, dlatego nasza klasa musi korzystać z innej klasy biblioteki Javy.
W deklaracji klasy dopiszmy polecenie “extends” (tzn. pobieramy dla naszej klasy cechy, metody oraz właściwości klasy nadrzędnej) a dalej nazwę tej klasy. W tym przypadku posłużymy się klasą “Frame” (Ramka). Lecz żeby skorzystać z tej klasy musimy do naszego projektu zaimportować wymagane pakiety, zawierające odpowiednie komponenty służące do tworzenia aplikacji okienkowych. Na początek zaimportujmy klasę “awt”. Powinno to wyglądać tak:
import java.awt.*;
public class naszaKlasa extends Frame
{
}
Teraz powinniśmy utworzyć konstruktor naszej klasy w następujący sposób:
import java.awt.*;
public class naszaKlasa extends Frame
{
public naszaKlasa()
{
}
}
W konstruktorze zainicjujemy aplikację okienkową:
import java.awt.*;
public class naszaKlasa extends Frame
{
public naszaKlasa()
{
super("Aplikacja okienkowa"); // inicjacja okienka z tytułem aplikacji
setSize(700,450); // ustawienie rozmiaru okienka aplikacji
setVisible(true); // ustawienie widoczności okienka
repaint(); // metoda "odświeżenie widoku"
}
}
Teraz możemy już uzupełnić tylko metodę “main”, aby uruchomić aplikację okienkową:
import java.awt.*;
public class naszaKlasa extends Frame
{
public naszaKlasa()
{
super("Aplikacja okienkowa"); // inicjacja okienka z tytułem aplikacji
setSize(700,450); // ustawienie rozmiaru okienka aplikacji
setVisible(true); // ustawienie widoczności okienka
repaint(); // metoda "odświeżenie widoku"
}
public static void main(Strings[] args)
{
new naszaKlasa(); // tworzymy nową instancję naszej klasy
}
}
Po uruchomieniu powinniśmy zobaczyć okno aplikacji. Sama aplikacja na razie nic nie robi, jednak poprzez dodanie innych komponentów takich jak przyciski, listy, czy pola tekstowe, będziemy w stanie stworzyć już małą użyteczną aplikację. Jak to zrobić? Kod poniżej przedstawia małą aplikację, która umożliwia, dokonanie prostych operacji matematycznych.
Dodajmy teraz do naszej aplikacji elementy interfejsu. A będą to trzy pola tekstowe, jeden przycisk oraz lista. Kod poniżej przedstawia klasę.
import java.awt.*;
public class naszaKlasa extends Frame
{
TextField pole1,pole2,pole3; //Deklaracja kontrolek interfejsu
Button przycisk;
List lista;
public naszaKlasa()
{
super("Aplikacja okienkowa"); // inicjacja okienka z tytułem aplikacji
setSize(700,450); // ustawienie rozmiaru okienka aplikacji
setVisible(true); // ustawienie widoczności okienka
setLayout(null); // wyłączenie automatycznego rozkładu elementów interfejsu
pole1 = new TextFiled();// nowy obiekt klasy TextField
pole1.setBounds(10,30,100,20); // ustawienie położenia komponentu w oknie aplikacji
add(pole1); // dodanie pola do okna aplikacji
pole2 = new TextField();
pole2.setBounds(120,30,100,20);
add(pole2);
pole3 = new TextField();
pole3.setBounds(230,30,150,20);
add(pole3);
przycisk = new Button("Oblicz");
przycisk.setBounds(390,30,100,20);
add(przycisk);
lista = new List();
lista.setBounds(500,30,150,100);
lista.add("Dodawanie"); // dodawanie pozycji do listy - metodą add(String)
lista.add("Odejmowanie");
lista.add("Mnożenie");
lista.add("Dzielenie");
add(lista);
repaint(); // metoda "odświeżenie widoku"
}
public static void main(Strings[] args)
{
new naszaKlasa(); // tworzymy nową instancję naszej klasy
}
}
Interfejs graficzny naszej aplikacji jest przygotowany. Teraz powinniśmy oprogramować działanie przycisku, po kliknięciu i wprowadzeniu danych wejściowych oraz wyborze operacji z listy, wykona obliczenie i wyświetli wynik w trzecim polu tekstowym.
Aby to wykonać powinniśmy zaimportować kolejny pakiet klasy “java.awt.event.*;” i dodać go do projektu podobnie jak poprzednio “awt”. Odpowiada on za import klas interfejsu.
import java.awt.event.*;
Nasza klasa powinna implementować interfejs (taka specjalna klasa), który nasłuchuje zdarzeń związanych z komponentami umieszczonymi w oknie aplikacji. Ten interfejs to “ActionListener”. Jak to zrobić? W deklaracji klasy dopisujemy:
public class naszaKlasa extends Frame implements ActionListener
Ponieważ chcemy, aby źródłem zdarzenia w aplikacji był przycisk, powinniśmy teraz do przycisku dodać interfejs nasłuchujący zdarzenia w taki sposób:
przycisk.addActionListener(this);
Oraz zaimplementować jedną wymaganą metodę interfejsu (bez niej kompilator będzie pokazywał błąd!) “actionPerformed”, która wykonuje kod związany ze zdarzeniami interfejsu “ActionListener”. Metoda wygląda tak:
public void actionPerformed(ActionEvent e)
{
if(e.getSource() == przycisk && lista.getSelectedIndex() == 0)//Jeśli źródłem zdarzenia jestprzycisk
{ // i zaznaczona pozycja w liście jest zerem
dodawanie(); // wywołanie metody
}
if(e.getSource() == przycisk && lista.getSelectedIndex() == 1)
{
odejmowanie();
}
if(e.getSource() == przycisk && lista.getSelectedIndex() == 2)
{
mnożenie();
}
if(e.getSource() == przycisk && lista.getSelectedIndex() == 0)
{
dzielenie();
}
}
Metodę tą zdeklarujemy w ciele klasy a nie konstruktora. Wyjaśnię teraz, o co chodzi w metodzie.
Metoda najpierw sprawdza warunek czy źródłem zdarzenia jest “przycisk” i wybrana pozycja z listy ma określony indeks. Jeśli warunek jest spełniony to wywołuje odpowiednią akcję. Przy czym trzeba pamiętać, że lista jest indeksowana od zera. Oczywiście pozostaje nam napisanie metod bezpośrednio odpowiadających za wykonanie obliczeń. Metody są nazwane zgodnie z rodzajem wykonywanych obliczeń, czyli np: metoda “dodawanie”, dodaje dwie liczby i zwraca wynik dodawania. Pozostałe metody działają analogicznie. Metody obliczeniowe również umieszczamy w ciele klasy. Po uruchomieniu programik będzie wykonywał zaplanowane przez nas czynności. Kod całego programu wygląda tak:
import java.awt.*;
import java.awt.event.*;
public class naszaKlasa extends Frame implements ActionListener
{
TextField pole1,pole2,pole3; //Deklaracja kontrolek interfejsu
Button przycisk;
List lista;
public naszaKlasa()
{
super("Aplikacja okienkowa"); // inicjacja okienka z tytułem aplikacji
setSize(700,450); // ustawienie rozmiaru okienka aplikacji
setVisible(true); // ustawienie widoczności okienka
setLayout(null); // wyłączenie automatycznego rozkładu elementów interfejsu
pole1 = new TextFiled();
pole1.setBounds(10,30,100,20);
add(pole1);
pole2 = new TextField();
pole2.setBounds(120,30,100,20);
add(pole2);
pole3 = new TextField();
pole3.setBounds(230,30,150,20);
add(pole3);
przycisk = new Button("Oblicz");
przycisk.setBounds(390,30,100,20);
przycisk.addActionListener(this);
add(przycisk);
lista = new List();
lista.setBounds(500,30,150,100);
lista.add("Dodawanie");
lista.add("Odejmowanie");
lista.add("Mnożenie");
lista.add("Dzielenie");
add(lista);
repaint(); // metoda "odświeżenie widoku"
}
///////////////////////////////Metody obliczeniowe///////////////////////////////
public void dodawanie()
{
double liczba1,liczba2,wynik;
liczba1 = Double.parseDouble(pole1.getText());
liczba2 = Double.parseDouble(pole2.getText());
wynik = liczba1 + liczba2;
pole3.setText(String.valueOf(wynik));
}
public void odejmowanie()
{
double liczba1,liczba2,wynik;
liczba1 = Double.parseDouble(pole1.getText());
liczba2 = Double.parseDouble(pole2.getText());
wynik = liczba1 - liczba2;
pole3.setText(String.valueOf(wynik));
}
public void mnożenie()
{
double liczba1,liczba2,wynik;
liczba1 = Double.parseDouble(pole1.getText());
liczba2 = Double.parseDouble(pole2.getText());
wynik = liczba1 * liczba2;
pole3.setText(String.valueOf(wynik));
}
public void dzielenie()
{
double liczba1,liczba2,wynik;
liczba1 = Double.parseDouble(pole1.getText());
liczba2 = Double.parseDouble(pole2.getText());
wynik = liczba1 / liczba2;
pole3.setText(String.valueOf(wynik));
}
/////////////////////////////////////////////////////////////////////////////////
public void actionPerformed(ActionEvent e)
{
if(e.getSource() == przycisk && lista.getSelectedIndex() == 0)
{
dodawanie();
}
if(e.getSource() == przycisk && lista.getSelectedIndex() == 1)
{
odejmowanie();
}
if(e.getSource() == przycisk && lista.getSelectedIndex() == 2)
{
mnożenie();
}
if(e.getSource() == przycisk && lista.getSelectedIndex() == 0)
{
dzielenie();
}
}
public static void main(Strings[] args)
{
new naszaKlasa();
}
}
Oczywiście pozostaje kwestia walidacji danych, a mówiąc prosto – program powinien sprawdzać czy dostarczone dane do obliczeń są poprawnym rodzajem danych. Można to łatwo sprawdzić wprowadzając, jako dane np. litery, lub znaki specjalne z klawiatury. Co się wówczas stanie? Oczywiście program wygeneruje błąd. Ale o tym jak sobie poradzić z tym problemem napiszę w następnym artykule.
Autor: Wojciech Wszelaki
