Instrukcja do zajęć laboratoryjnych
Java NetBeans
Data: 08.04.2008 r.
Spis treści
1. WPROWADZENIE ............................................................................................................................................... 2
2. TWORZENIE PROJEKTU - PODSTAWY ................................................................................................................. 3
3. TWORZENIE PROJEKTU  PRZYKA
AD Z WA
ASNYM PAKIETEM ............................................................................. 9
3. TWORZENIE GUI  DODAWANIE 2. LICZB ..........................................................................................................18
2
1. Wprowadzenie
NetBeans jest projektem typu "open source" o coraz większej popularności i stale wzrastającej
społeczności u\
ytkowników. O wielkim sukcesie NetBeans świadczy fakt, \
e z projektem tym
współpracuje ju\
prawie 100 (znaczących!) firm na całym świecie. Projekt NetBeans został
uruchomiony w czerwcu 2000 roku przez firmę Sun Microsystems będącą od tej pory głównym
jego sponsorem.
Obecnie istnieją dwa główne produkty: NetBeans IDE i NetBeans Platform. Oprócz nich dostępne
są dwa inne, będące rozszerzeniami do IDE: NetBeans Mobility Pack oraz NetBeans Profiler.
NetBeans IDE jest środowiskiem programistycznym (Integrated Development Environment - IDE)
- narzędziem słu\
ącym do tworzenia, kompilowania, uruchamiania i testowania programów. Całe
IDE jest napisane w Javie, jednak umo\
liwia ono równie\
tworzenie programów w innych
językach. Ponadto (oprócz NetBeans Mobility Pack i NetBeans Profiler) dostępna jest du\
a ilość
modułów rozszerzających jego mo\
liwości. NetBeans IDE jest produktem dostępnym za darmo
oraz bez \
adnych ograniczeń co do jego u\
ywania.
Dostępna jest równie\
NetBeans Platform - jest to modułowa i łatwo rozszerzalna baza, słu\
ąca
jako podstawa do tworzenia du\
ych aplikacji typu "desktop". Oprócz tego niezale\
ni dostawcy
oprogramowania dostarczają ró\
nego typu wtyczki i rozszerzenia, które łatwo integrują się z
NetBeans Platform i mogą być u\
yte do tworzenia własnych narzędzi i rozwiązań.
Wszystkie produkty NetBeans są tworzone jako "open source" i dostępne są za darmo zarówno do
komercyjnych jak i niekomercyjnych zastosowań. Kod z
ródłowy obu produktów dostępny jest na
licencji Common Development and Distribution License (CDDL).
3
2. Tworzenie projektu - podstawy
Poni\
ej przedstawiono etapy tworzenia prostego projektu
1. Uruchom NetBeans IDE
2. Wybierz File->New Project->Java->JavaApplication->Next
3. Wpisz nazwę projektu w swoim katalogu roboczym i wciśnij przycisk Finish. Zwróć uwagę na
zaznaczone opcje  Set as Main Project i  Create Main Class .
4
4. Automatycznie zostanie utworzony projekt z ró\
nymi katalogami i plikami. Przejrzyj zawartość
wszystkich katalogów projektu.
5. Warto równie\
przejrzeć utworzony katalog i pliki korzystając np. z Total Commandera.
5
6. W edytorze otwórz plik z główną metodą  main .
7. W miejsce komentarza  TODO code application logic here wpisz swój kod, tj. linijkę z kodem:
System.out.println("Hello World!"); . W czasie pisania kodu korzystaj z automatycznych
podpowiedzi tak jak pokazano poni\
ej. Okno z dostępnymi metodami mo\
na wywołać wciskając
klawisze: Ctrl + Spacja (klawisz Ctrl i jednocześnie spacja). Warto zauwa\
yć, \
e pokazuje się
równie\
krótki opis działania metody.
6
8. I tak powinno wyglądać ciało metody  main . Nie zapomnij zapisać projektu.
9. Teraz mo\
esz przystąpić do kompilacji projektu wybierając z menu Bulid->Build Main Project
lub wciskając przycisk F11.
7
10. W wyniku kompilacji w okienku  Output powinny pojawić się komunikaty tak jak poni\
ej.
11. Teraz mo\
esz przystąpić do uruchomienia programu wybierając z menu Run->Run Main
Project lub wciskając klawisz F6.
12. W oknie  Output pojawi się rezultat działania napisanego programu.
8
13. Pamiętaj, \
e automatycznie zostanie utworzony plik o nazwie projektu i rozszerzeniu  jar . W
tym przypadku jest to plik  HelloWorldApp.jar . Są to zarchiwizowane wszystkie niezbędne
pliki projektu. Aplikację mo\
esz uruchomić korzystając z linii poleceń i wpisując: java  jar
 HelloWorldApp.jar .
14. A teraz samodzielnie utwórz i uruchom nowy, inny prosty projekt..
9
3. Tworzenie projektu  przykład z własnym pakietem
Opracowano na podstawie materiałów z http://www.netbeans.org/kb/50/index.html.
Tworzenie Projektu
Na początku utworzymy nową bibliotekę klas Java dla klas pomocniczych, których u\
yjemy póz
niej. Następnie
nale\
y utworzyć nową aplikację Java, która będzie stanowić projekt główny. Kiedy projekt MyApp będzie ju\

gotowy dodamy do jego classpath klasy z MyLib.
Tworzenie Nowej Biblioteki Klas Java
1. Wybierz File > New Project (Ctrl-Shift-N). W Categories wybierz Java. W Projects wybierz Java Class
Library i naciśnij Next.
MyLib
2. W polu Project Name wpisz . Ustaw poło\
enie projektu na dowolny katalog na twoim
NetBeans_projects
komputerze. Od tego momentu będziemy odwoływać się do tego katalogu jako .
/
Uwaga: Podana ście\
ka powinna wyglądać tak: NetBeans_projects/MyLib/
3. Naciśnij Finish. Projekt MyLib zostanie otwarty w oknach zarówno Projects jak i Files.
10
Tworzenie Nowej Aplikacji Java
1. Wybierz File > New Project. Pod Categories, wybierz Java. Pod Projects, wybierz Java Application i
naciśnij Next.
MyApp NetBeans_projects
2. W polu Project Name wpisz . Upewnij się, \
e lokalizacja projektu to .
acrostic.Main
3. Wprowadz
jako klasę główną.
4. Upewnij się, \
e pola Set as Main Project oraz Create Main Class są zaznaczone.
Main.java
5. Naciśnij Finish. Projekt MyApp pojawi się w oknie Project a otworzy się w oknie Edytora
Kodu y
ródłowego(Source Editor).
11
Konfiguracja Classpath Kompilacji
1. W oknie Projects, kliknij prawym klawiszem myszy na Libraries dla projektu My App i wybierz Add
Project.
/ i wybierz folder projektu MyLib. Project JAR Files pokazuje pliki
NetBeans_projects
2. Przejdz
do
JAR, które mogą być dodane do projektu. Zauwa\
, \
e plik JAR dla MyLib jest obecny pomimo, \
e nie
utworzyliśmy jeszcze \
adnego pliku JAR. Ten plik JAR zostanie utworzony za pierwszym i ka\
dym
kolejnym razem gdy będziemy budować i uruchamiać projekt MyApp.
12
3. Kliknij na Add Project JAR Files.
4. Rozwiń odgałęzienie Libraries. Zauwa\
, \
e plik JAR z MyLib jest dodany do classpath projektu MyApp.
Pisanie i Edytowanie Kodu y
ródłowego Java
Teraz potrzebujemy utworzyć pakiet Java i dodać metody, których u\
yjemy przy konstruowaniu naszego
acrostic Main
akrostychu, po czym zaimplementujemy metodę w klasie .
13
Tworzenie Plików oraz Pakietów Klas Java
LibClass
1. Kliknij prawym przyciskiem myszy na projekcie MyLib i wybierz New > Java Class. Wpisz
org.me.mylib LibClass.java
jako nazwę nowej klasy, wpisz w polu Package i kliknij Finish.
zostanie otwarta w oknie Edytora Kodu y
ródłowego.
LibClass.java public LibClass() {
2. W , przejdz
do linii pomiędzy deklaracją klasy ( ) a
public class LibClass {) wpisz albo skopiuj i wklej poni\
szy kod metody:
konstruktorem (
3. public static String acrostic(String[] args) {
4. StringBuffer b = new StringBuffer();
5. for (int i = 0; i < args.length; i++) {
6. if (args[i].length() > i) {
7. b.append(args[i].charAt(i));
8. } else {
9. b.append('?');
10. }
11. }
12. return b.toString();
}
13. Jeśli wklejony kod jest niepoprawnie sformatowany, naciśnij Ctrl-Shift-F aby przeformatować cały plik.
14. Naciśnij Ctrl-S, \
eby zapisać utworzony plik.
14
Edytowanie Pliku Java
Main.java w Edytorze Kodu y
ródłowego. Jeśli nie jest ju\
otwarta, rozwiń MyApp >
1. Wybierz zakładkę
Main.java
acrostics w oknie Projects i kliknij dwa razy .
// TODO code application logic here main
2. Usuń z kodu komentarz w metodzie i wpisz:
String result = Li
3. Naciśnij Ctrl-Spacja \
eby otworzyć okno automatycznego uzupełniania kodu. IDE oferuje uzupełnianie
LibClass
kodu dla wszystkich klas znajdujących się w classpath kompilacji projektu. Wybierz
(org.me.mylib)
i naciśnij Enter. IDE uzupełnia resztę nazwy klasy ale równie\
automatycznie tworzy
deklarację import dla klasy.
Uwaga: IDE wyświetla równie\
drugie okno nad oknem uzupełniania kodu zwierające Javadoc dla
wybranej klasy lub pakietu. Z uwagi na to, \
e dla większości pakietów Javadoc nie ma, dopóki nie
podświetli się jakiejś klasy, w oknie będzie widoczna informacja o tym, \
e "Nie mo\
na znalez
ć
Javadoc".
LibClass
4. W głównej klasie wstaw kropkę po . Okno uzupełniania kodu pojawi się ponownie. Wybierz
acrostic(String[]args) acrostic
metodę i naciśnij Enter. IDE wstawia metodę i polazuje jej
parametry w dymku podpowiedzi.
args
5. Naciśnij jeszcze raz Ctrl-Spacja \
eby wyświetlić okno uzupełniania kodu, wybierz i naciśnij Enter.
6. Wstaw średnik. Zauwa\
, \
e jest on wstawiany po prawym nawiasie pomimo, i\
punkt w którym został
wstawiony jest jeszcze wewnątrz nawiasów. Ostatecznie linijka kodu będzie wyglądać tak:
String result = LibClass.acrostic(args);
sout i naciśnij spację. Skrót sout zostaje
7. Naciśnij Enter, \
eby przejść do nowej linii. Wpisz
System.out.println("");
automatycznie zamieniony na z kursorem między cudzysłowami. Wpisz
Result = + result
między cudzysłowami i za drugim cudzysłowem. W rezultacie powinniśmy
otrzymać:
System.out.println("Result = " + result);
15
8. Naciśnij Ctrl-S \
eby zapisać zmiany.
Kompilacja i Uruchamianie Projektu
W tym momencie nale\
y ustawić argumenty uruchomieniowe aplikacji i klasy main, \
eby mo\
na było projekt
uruchomić. Zwrócimy równie\
uwagę na narzędzia czyszczące kod oraz budowania i generowania dokumentacji
Javadoc.
Ustawianie Argumentów Uruchomieniowych
1. Kliknij prawym klawiszem na MyApp w oknie projektu, wybierz Properties i kliknij na Run po lewej
acrostic.Main
stronie okna dialogowego. Zauwa\
, \
e klasa główna jest ju\
ustawiona jako .
However we all feel zealous
2. Wpisz w polu Arguments i kliknij OK.
Uruchamianie Głównego Projektu
1. Wybierz Run > Run Main Project (F6) z menu Run. Kliknij dwukrotnie na oknie Output, \
eby je
MyLib.jar
zmaksymalizować by móc widzieć całość wyjścia. Zauwa\
, \
e Ant najpierw tworzy , a
Result =
dopiero póz
niej przy jego u\
yciu kompiluje MyApp. Na końcu wypisuje wyjście programu,
Hello
(jest to akrostych wyra\
enia podanego programowi jako argument uruchomieniowy).
16
build
2. Wybierz okno Files i rozwiń folder projektu MyApp. Zbudowane pliki znajdują się w folderze .
3. Naciśnij F6, \
eby uruchomić program. Nie ma potrzeby kompilować niczego od nowa, a program
zostaje uruchomiony.
Czyszczenie i Budowanie Projektu
1. Wybierz Build > Clean and Build Main Project (Shift-F11). Podczas tego procesu oba projekty, MyLib i
MyApp, są czyszczone i ponownie budowane.
2. Kliknij prawym przyciskiem myszy na projekt MyLib w oknie Projects i wybierz Clean Project. Tym
razem wyczyszczony zostanie jedynie projekt MyLib.
Budowanie Pojedynczego Projektu
1. Kliknij prawym przyciskiem na MyLib w oknie Projects.
2. Wybierz z menu kontekstowego Build Project.
Generowanie Javadoc
1. Wybierz projekt MyLib.
2. W głównym menu IDE kliknij Build > Generate Javadoc for Project "MyLib".
IDE wyświetli wyjście Javadoc w oknie Output, a przeglądarka internetowa zostanie otwarta
wyświetlając Javadoc.
Testowanie i Debugowanie Projektu
Teraz u\
ywając JUnit utworzymy i uruchomimy dla naszego projektu test, a następnie uruchomimy go w
debugerze IDE, \
eby sprawdzić czy program nie zawiera błędów.
Tworzenie Testów JUnit
LibClass.java w oknie Projects i wybierz Tools >Create JUnit Tests
1. Kliknij prawym przyciskiem na
(Ctrl-Shift-U). Kliknij OK aby uruchomić test z ustawieniami domyślnymi. IDE tworzy pakiet
org.me.mylib oraz plik LibClassTest.java w pakiecie Test Packages.
17
LibClassTest.java testAcrostic
2. W , usuń ciało metody i wpisz albo wklej w to miejsce poni\
szy
kod:
3. System.err.println("Running testAcrostic...");
4. String result = LibClass.acrostic(new String[]
5. {"fnord", "polly", "tropism"});
assertEquals("Correct value", "foo", result);
6. Zapisz plik naciskając Ctrl-S.
Uruchamianie Testów JUnit
1. Zaznacz projektu MyLib i wybierz z menu IDE: Run > Test "MyLib" (Alt-F6). W oknie Output pojawia się
MyLib (test)
zakładka . Testy JUnit są kompilowane i uruchamiane. Dane na wyjściu testu JUnit
wskazują, \
e program przeszedł go pomyślnie.
2. Zamiast testować od razu cały projekt, mo\
na równie\
przeprowadzić test oddzielnie dla pojedynczego
LibClass.java
pliku. Wybierz zakładkę w Edytorze Kodu y
ródłowego i z menu IDE wybierz: Run >
Run File > Test "LibClass.java".
Debugowanie Projektu
LibClass.java acrostic
1. W pliku , przejdz
do metody i ustaw kursor gdziekolwiek w kodzie
b.append(args[i].charAt(i));
. Naciśnij teraz Ctrl-F8 aby ustawić w tym miejscu breakpoint.
2. Wybierz Run > Debug Main Project (F5). IDE otwiera okna debugowania i uruchamia program do chwili
dojścia do ustawionego wcześniej breakpointa.
args
3. Wybierz okno Local Variables i rozwiń . Tablica łańcuchów literowych zawiera tekst wprowadzony
wcześniej jako argument uruchomieniowy programu.
4. Kliknij Step Into (F7) w pasku narzędziowym \
eby program został wykonany do końca i zobacz jak
tworzony jest akrostych.
W momencie kiedy program kończy działanie, okna debugera zamykają się.
18
3. Tworzenie GUI  dodawanie 2. liczb
Exercise 1: Creating a Project
The first step is to create an IDE project for the application that we are going to develop. We will name our
project NumberAddition.
1. Choose File > New Project. Alternatively, you can click the New Project icon in the IDE toolbar.
2. In the Categories pane, select the Java node. In the Projects pane, choose Java Application. Click Next.
NumberAddition
3. Type in the Project Name field and specify a path e.g. in your home directory as the
project location.
4. Ensure that the Set as Main Project checkbox is selected. Deselect the Create Main Class checkbox if it
is selected.
5. Click Finish.
Exercise 2: Building the Front End
To proceed with building our interface, we need to create a Java container within which we will place the other
JFrame
required GUI components. In this step we'll create a container using the component. We will place the
container in a new package, which will appear within the Source Packages node.
Create a JFrame container
1. In the Projects window, right-click the NumberAddition node and choose New > JFrame Form.
2. Enter NumberAdditionUI as the class name.
my.numberaddition
3. Enter as the package.
4. Click Finish.
19
NumberAdditionUI NumberAdditionUI
The IDE creates the form and the class within the
NumberAddition NumberAdditionUI
application, and opens the form in the GUI Builder. The
my.NumberAddition
package replaces the default package.
Adding Components: Making the Front End
Next we will use the Palette to populate our application's front end with a JPanel (Panel). Then we will add
three JLabels, three JTextFields, and three JButtons.
If you do not see the Palette window in the upper right corner of the IDE, choose Windows >
Palette.
1. Start by selecting a JPanel from the Palette and drop it onto the JFrame.
2. While the JPanel is highlighted, go to the Properties window and click the ellipsis (...) button next to
Border to choose a border style.
Number Addition
3. In the Border dialog, select TitledBorder from the list, and type in in the Title field.
Click OK to save the changes and exit the dialog.
20
4. You should now see an empty titled JFrame that says Number Addition like in the screenshot. Look at
the screenshot and add three JLabels, three JTextFields and three JButtons as you see above.
Renaming the Components
In this step we are going to rename the display text of the components that were just added to the JFrame.
jLabel1 First Number
1. Double-click and change the text property to
jLabel2 Second Number
2. Double-click and change the text to
jLabel3 Result
3. Double-click and change the text to
jTextField1
4. Double-click and remove the sample text in the text field. You may have to resize the
jTextField1 jTextField2 jTextField3
to its original size. Repeat this step for and .
jButton1 and rename it Clear.
5. Double-click
jButton2 and rename it Add.
6. Double-click
21
jButton3 Exit
7. Double-click and rename it .
Your Finished GUI should now look like the following screenshot:
Exercise 3: Adding Functionality
jTextField1
In this exercise we are going to give functionality to the Add, Clear, and Exit buttons. The and
jTextField2 jTextField3
boxes will be used for user input and for program output - what we are creating
is a very simple calculator. Let's begin.
Making the Exit Button Work
In order to give function to the buttons, we have to assign an event handler to each to respond to events. In
our case we want to know when the button is pressed, either by mouse click or via keyboard. So we will use
ActionListener responding to ActionEvent.
1. Right click the Exit button. From the pop-up menu choose Events > Action > ActionPerformed. Note
that the menu contains many more events you can respond to! When you select the actionPerformed
event, the IDE will automatically add an ActionListener to the Exit button and generate a handler
method for handling the listener's actionPerformed method.
2. The IDE will open up the Source Code window and scroll to where you implement the action you want
the button to do when the button is pressed (either by mouse click or via keyboard). Your Source Code
window should contain the following lines:
3. private void jButton3ActionPerformed(java.awt.event.ActionEvent evt) {
4. //TODO: Add your handling code here:
}
22
5. We are now going to add code for what we want the Exit Button to do. You will have to type
System.exit(0); to the above code, replacing the TODO line. Your finished Exit button code should look
like this:
Making the Clear Button Work
1. Click the Design tab at the top of your work area to go back to the Form Design
jButton1
2. Right click the Clear button ( ). From the pop-up menu select Events > Action >
actionPerformed.
3. We are going to have the Clear button erase all text from the jTextFields. To do this, you will add some
code like above. Your finished source code should look like this:
4. private void jButton1ActionPerformed(java.awt.event.ActionEvent evt){
5. jTextField1.setText("");
6. jTextField2.setText("");
7. jTextField3.setText("");
}
The above code changes the text in all three of our JTextFields to nothing, in essence it is overwriting the
existing Text with a blank.
Making the Add Button Work
The Add button will perform three actions.
jTextField1 jTextField2
1. It is going to accept user input from and and convert the input from a
type String to a float.
2. It will then perform addition of the two numbers and finally,
jTextField3
3. it will convert the sum to a type String and place it in .
Lets get started!
1. Click the Design tab at the top of your work area to go back to the Form Design.
jButton3
2. Right-click the Add button ( ). From the pop-up menu, select Events > Action >
actionPerformed
3. We are going to add some code to have our Add button work. The finished source code shall look like
this:
4. private void jButton2ActionPerformed(java.awt.event.ActionEvent evt){
5.
// First we define float variables.
6. float num1, num2, result;
7.
// We have to parse the text to a type float.
23
8. num1 = Float.parseFloat(jTextField1.getText());
9. num2 = Float.parseFloat(jTextField2.getText());
10. // Now we can perform the addition.
11. result = num1+num2;
12. // We will now pass the value of result to jTextField3.
13. // At the same time, we are going to
14. // change the value of result from a float to a string.
15. jTextField3.setText(String.valueOf(result));
}
Our program is now complete we can now build and run it to see it in action.
Exercise 4: Running the Program
The final step is to build and run the program.
1. Choose Build > Build Main Project.
2. When the Build output is finished, choose Run > Run Main Project
3. If you get a window informing you that Project NumberAddition does not have a main class set, then
you should select my.NumberAddition.NumberAdditionUI as the main class in the same window and
click the OK button.
4. Your created program is now running.
In this tutorial you learned how you hook up functionality to GUI components with the NetBeans GUI Builder.
Zadania
1. Rozszerz mo\
liwości powy\
szego projektu o funkcje odejmowania,
mno\
enia i dzielenia.
2. Zaprojektuj prosty kalkulator (przyciski: 0-9, +, -, *,/, =, okno z
wynikiem).