|
|
|||
|
|
09/11/2010 |
|
|
|
|
|
|
In aceasta lucrare de laborator vor fi acoperite
urmatoarele probleme:
- Introducere in applet-uri si adaugarea componentelor Swing si a
interactivitatii in applet-uri
- Mediul de dezvoltare integrat (IDE)
NetBeans
- Crearea unui applet pornind de la
zero
- Anexe (proceduri de instalare pentru kitul
NetBeans)
Unul dintre tipurile de programe ce pot fi create
cu ajutorul limbajului Java este applet-ul.
Applet-ul cunoscut si sub numele de mini-aplicatie Java este un program
specializat care este executat si vizualizat in cadrul unui browser web
(Internet Explorer, Mozilla, etc.). Cand pagina web pe care este plasat
applet-ul este încarcata in browser, programul va fi si el incarcat si lansat
in executie. Applet-urile nu
sunt aplicatii complete, ci componente care ruleaza in mediul browser-ului.
Browser-ul informeaza applet-ul asupra evenimentelor care se petrec pe
durata de viata a applet-ului. Serviciile oferite de browser sunt:
In cazul dezvoltarii unei aplicatii standard in
Java, asa cum a fost prezentat in primele laboratoare, este necesara
specificarea unei metode main(), pe
care programul o executa la inceput. In cadrul metodei main() este specificata functionalitatea aplicatiei. In cazul unui
applet, pe de alta parte, trebuie definite o serie de metode suplimentare care
raspund la evenimente invocate de browser pe durata de viata a unui applet.
Aceste metode sunt:
Aceste metode sunt
apelate automat de browser si nu trebuie apelate explicit in program. Invocarea ultimelor doua metode conduce la "omorarea"
tuturor firelor de executie ale applet-ului
si la eliberarea tuturor
resurselor alocate acestuia.
Urmatorul applet simplu:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 |
import java.applet.Applet; import java.awt.Graphics; public class Simple extends Applet { StringBuffer buffer; public void init() { buffer = new StringBuffer(); addItem("initializing...
"); } public void start() { addItem("starting... "); } public void stop() {
addItem("stopping... "); } public void destroy() { addItem("preparing for
unloading..."); } void addItem(String
newWord) { System.out.println(newWord); //
afisare in Java Console a browser-ului buffer.append(newWord); repaint();
// apeleaza paint() } public void paint(Graphics g) { //Draw a Rectangle around the
applet's display area. g.drawRect(0, 0, size().width - 1,
size().height - 1); //Draw the current string inside the
rectangle. g.drawString(buffer.toString(), 5,
15); } } |
permite, prin vizualizarea lui, urmarirea fazelor ciclului de viata ale unui applet. Pentru a
vedea consola din dreapta, in Internet Explorer se foloseste Tools
si se selecteaza Sun Java Console.
Pentru crearea unui proiect nou de tip applet Java
de la zero trebuie parcursi urmati pasii:
In laborator: 1. Se lanseaza in
executie mediul de dezvoltare integrat NetBeans; 2. Se selecteaza File -> New Project... 3. In zona Categories
se selecteaza Java, iar in zona Projects se selecteaza Java Class Library. Apoi Next. 4. Se denumeste proiectul: HelloApplet 5. Se va specifica
locatia unde se va salva proiectul ( D:\LPAI\Laborator3\GrupaXYZ ). Apoi Finish. 6. Din subfereastra Projects, cu click dreapta pe nodul
de proiect HelloApplet, se deschide meniul
pop-up, New -> Other... 7. Din zona Categories se selecteaza Java, iar din zona File Types se selecteaza Japplet. Apoi Next. 8. Se va
stabili numele clasei: AppletSalut, iar in campul Package, se introduce: Test. Apoi Finish. |
Mediul integrat de dezvoltare (IDE-ul) NetBeans
plaseazã fiºierul sursã applet în pachetul specificat anterior, denumit: Test. Codul sursa al applet-ului se va
deschide in fereastra principala aflata in partea dreapta (editorul de surse).
In mod predefinit aceasta contine urmatoarea secventa de cod:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
/* * To change this template, choose Tools |
Templates * and open the template in the editor. */ package Test; import javax.swing.JApplet; /** * * @author LPAI */ public class AppletSalut extends JApplet { /** * Initialization method that will be
called after the applet is loaded * into the browser. */ public
void init() { // TODO start asynchronous download
of heavy resources } // TODO overwrite start(), stop() and
destroy() methods } |
Codul de mai sus se va inlocui cu o secventa de
applet simpla:
1 2 3 4 5 6 7 8 9 10 |
package Test; import javax.swing.*; // clasa
importata pentru a se crea un applet import java.awt.*; // clasa
importata pentru a se utiliza scriere grafica public class AppletSalut extends JApplet { // se extinde JApplet public void paint(Graphics g) {
// declaratie metoda desenare g.setColor(Color.GREEN); g.drawString("Salut utilizator!", 50, 70); // apel metoda
scriere grafica } } |
Applet-ul implementat
mosteneste clasa Japplet care este accesibila prin importarea
pachetului de clase javax.swing.* .
Pe langa acestea, applet-ul contine elemente de interfata grafica pentru
dialogul cu utilizatorul (prin importul pachetului java.awt.). Appletul va afisa mesajul “Salut utilizator!” in cadrul
ferestrei appletului (datorita apelului metodei drawString()), in culoarea verde (prin apelul metodei setColor()). De fiecare data cand
trebuie sa se afiseze sau sa se actualizeze fereastra appletului, Java apeleaza
metoda paint(). Acest applet poate
fi vazut fie cu ajutorul unui browser web, fie cu ajutorul programului NetBeans
care contine un utilitar de vizualizare de appleturi.
In laborator: 1. Din fereastra Projects, se deschide meniul pop-up
cu click dreapta pe nodul de proiect HelloApplet si se selecteaza Build (Este creat astfel in
directorul dist, fisierul arhiva AppletSalut.jar). 2. Din fereastra Projects, se deschide meniul pop-up cu click dreapta pe nodul de
proiect HelloApplet si se selecteaza Run File (Este creat astfel in
directorul build, fisierul html
care include appletul AppletSalut.html). Appletul va fi
lansat automat cu ajutorul AppletViewer-ului. |
Continutul fisierului AppletSalut.html generat automat in
urma executiei este urmatorul:
<HTML> <HEAD> <TITLE>Applet
HTML Page</TITLE> </HEAD> <BODY> <H3><HR
WIDTH="100%">Applet HTML Page<HR
WIDTH="100%"></H3> <P> <APPLET
codebase="classes" code="Test/NewJApplet.class" width=350
height=200></APPLET> </P> <HR
WIDTH="100%"><FONT SIZE=-1><I>Generated by NetBeans
IDE</I></FONT> </BODY> </HTML> |
Acest cod poate fi vizualizat si eventual modificat prin selectarea tabului „Files”, apoi se selecteaza Build -> classes -> AppletSalut.html. Codul sursa „html” se va afisa in fereastra principala aflata in partea dreapta.
In laborator: 1. Un exemplu mai complex de implementare a
appleturilor este dat de urmatorul cod, care va fi testat in laborator. |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 |
package Test; import javax.swing.JApplet; import java.awt.Graphics; import java.util.Calendar; public class AppletData extends
JApplet { public void paint(Graphics g) { Calendar acum = Calendar.getInstance(); int minutul = acum.get(Calendar.MINUTE); int ora = acum.get(Calendar.HOUR_OF_DAY); int aziCaZiALunii = acum.get(Calendar.DAY_OF_MONTH); int luna = acum.get(Calendar.MONTH); int anul = acum.get(Calendar.YEAR); int aziCaZiASaptamanii = acum.get(Calendar.DAY_OF_WEEK); g.drawString("Salut
utilizator!", 50, 25); g.drawString("Azi suntem in
" + aziCaZiALunii + "." + luna + "." + anul + ".", 50, 65); g.drawString("Conform
ceasului calculatorului este ora " + ora + ":"
+ minutul + ".", 50, 85); switch (aziCaZiASaptamanii) { case 1: g.drawString("Azi este
duminica.", 50, 45); break; case 2: g.drawString("Azi
este luni.", 50, 45); break; case 3: g.drawString("Azi este
marti.", 50, 45); break; case 4: g.drawString("Azi este
miercuri.", 50, 45); break; case 5: g.drawString("Azi este
joi.", 50, 45); break; case 6: g.drawString("Azi este
vineri.", 50, 45); break; case 7: g.drawString("Azi este
sambata.", 50, 45); break; default: g.drawString("Acest text nu
ar trebui sa poata fi afisat.", 50, 45); } } } |
Programul ExtensieJApplet ilustreaza crearea unei miniaplicatii (applet) prin extinderea clasei JApplet, si asezarea
componentelor Swing relativ la margini -
BorderLayout.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 |
import java.awt.*; import javax.swing.*; /** * Demonstreaza extinderea JApplet pentru a o
miniaplicatie Java. */ public class ExtensieJApplet extends JApplet { /** * Metoda de initializare a appletului.
Apelata de browser la prima * utilizare a appletului, stabileste
layout-ul (modul de dispunere a * componentelor in panoul de continut) si adauga
componentele in panou. */
public void init() { // Obtinerea panoului de
continut intern cadrului (container de componente)
Container container = getContentPane(); // Asezarea componentelor in
panou (la 10 pixeli de marginea panoului)
container.setLayout(new BorderLayout(10, 10)); // Adaugarea a 5 butoane la
panoul appletului
container.add(new JButton("Est
(Dreapta)"), BorderLayout.EAST);
container.add(new JButton("Sud (Jos)"),
BorderLayout.SOUTH);
container.add(new JButton("Vest (Stanga)"),
BorderLayout.WEST);
container.add(new JButton("Nord (Sus)"),
BorderLayout.NORTH);
container.add(new JButton("Centru"),
BorderLayout.CENTER);
} } |
Applet-ul rezultat poate fi vizualizat intr-un
browser care va arata astfel:
Se va urmari in continuare, imbunatatirea
programului ExtensieJApplet
prin introducerea interactivitatii,
(detalii
privind interfetele grafice swing in
Java) ceea ce presupune tratarea evenimentelor din interfata grafica.
Spunem ca un program este controlat de evenimente daca acesta asteapta sa i se
ceara sa faca o anumita actiune.
In Java exista mai multe moduri de tratare a evenimentelor.
(1) implementand o metoda
numita action();
(2) implementand o metoda
numita handleEvent();
(3) implementand metode
specifice interfetelor grafice Swing;
Metodele (1) si (2) sunt valabile incepand chiar
din prima versiune Java – JDK 1.0, in timp ce metoda (3) a fost implementata
incepand cu versiunea JDK 1.1.
Acest mod de tratare a evenimentelor necesita 3 activitati din partea
programatorului:
- Varianta A – Implementare interfata:
I. Declararea unei clase care
sa implementeze o interfata «Action Listener» (ascultator de evenimente),
(contine metode ce trebuie implementate de utilizator pentru tratarea
evenimentului respectiv);
II. Implementarea tuturor
metodelor definite in interfata « Action Listener »;
III. Inregistrarea unui obiect
din clasa declarata in pasul I, la fiecare dintre componentele grafice (tinta /
sursa) pentru care se vrea tratarea evenimentului respectiv.
- Varianta B – Extindere clasa abstracta (adaptor):
I. Declararea unei clase care extinde o clasa
predefinita (abstracta, adaptor pentru interfata) care implementeaza o
interfata « Action Listener » (ascultator de evenimente);
II. Reimplementarea metodelor dorite din clasa
care implementeaza interfata;
III. Inregistrarea unui obiect din clasa declarata
in pasul I, la fiecare dintre componentele grafice (tinta / sursa) pentru care
se vrea tratarea evenimentului respectiv
Programul ExtensieInteractivaJApplet ilustreaza:
- crearea
unei miniaplicatii (applet) prin extinderea clasei Japplet;
- tratarea evenimentului
« actionare » pentru componentele de tip buton prin implementarea
variantei A;
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 |
import java.awt.*; import java.awt.event.*; import javax.swing.*; public class ExtensieInteractivaJApplet extends JApplet { public void init() { // Obtinerea panoului de
continut (content pane) creat de browser pentru // executia appletului (container in care vor fi plasate componentele) Container container = getContentPane(); // Stabilirea layout-ului
panoului, BorderLayout cu spatiu 10 pixeli container.setLayout(new BorderLayout(10, 10)); // Adaugarea a 5 butoane la panoul appletului // Referintele create
vor fi necesare si inregistrarii ascultatorilor JButton b1 = new JButton("Est (Dreapta)"); JButton b2 = new JButton("Sud
(Jos)"); JButton b3 = new JButton("Vest
(Stanga)"); JButton b4 = new JButton("Nord
(Sus)"); JButton b5 = new JButton("Centru"); container.add(b1,
BorderLayout.EAST); container.add(b2,
BorderLayout.SOUTH); container.add(b3,
BorderLayout.WEST); container.add(b4,
BorderLayout.NORTH); container.add(b5,
BorderLayout.CENTER); // Crearea unui obiect
"ascultator" de "evenimente actionare" // (pe care le trateaza) ActionListener
obiectAscultatorActionare = new ActionListener() { // Tratarea actionarii
unui buton public void actionPerformed(ActionEvent
ev) { // Mesaj informare in
consola Java
System.out.println("A fost apasat butonul " + ev.getActionCommand()); // Mesaj informare in
bara de stare showStatus("Apasat
butonul " + ev.getActionCommand()); } }; // Inregistrarea
"ascultatorului" de "evenimente actionare" la
"sursele" // de evenimente b1.addActionListener(obiectAscultatorActionare);
b2.addActionListener(obiectAscultatorActionare); b3.addActionListener(obiectAscultatorActionare); b4.addActionListener(obiectAscultatorActionare); b5.addActionListener(obiectAscultatorActionare); } } |
Applet-ul rezultat poate fi vizualizat intr-un
browser care va arata ca in figura de mai jos.
3.4.2.
Applet-uri standalone
In Java se pot creea de
asemenea si appleturi ca aplicatii de sine statatoare (desktop) care pot fi
executate cu ajutorul functiei main().
Programul AppletAplicatie
ce va fi prezentat in continuare exemplifica:
- crearea unei miniaplicatii (applet)
prin extinderea clasei JApplet:
- care utilizeaza componente grafice de tip:
- linie /
intrare de text – JTextField;
- zone
de text – JtextArea;
- tratarea evenimentelor
« action » pentru
componentele intrare de text;
- transformarea
miniaplicatiei in aplicatie de sine statatoare prin:
- adaugarea
metodei main();
- utilizarea unui obiect de tip JFrame cu
functionalitate echivalenta obiectului de tip JApplet.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 |
import java.awt.*; import java.awt.event.*; import javax.swing.*; /** * Ecou text grafic (applet si aplicatie de sine statatoare in acelasi
timp). */ public class AppletAplicatie
extends JApplet { public void init() { // Obtinerea panoului de
continut (content pane) creat de browser pentru // executia appletului (container in care vor fi plasate componentele) Container
containerCurent = this.getContentPane(); // Stabilirea layout-ului
panoului containerCurent.setLayout(new
BorderLayout()); final JTextArea outTextGrafic = new JTextArea(5, 40); // Zona non-editabila JScrollPane scrollPane = new JScrollPane(outTextGrafic, JScrollPane.VERTICAL_SCROLLBAR_ALWAYS,
JScrollPane.HORIZONTAL_SCROLLBAR_ALWAYS); final JScrollBar vertical =
scrollPane.getVerticalScrollBar(); containerCurent.add("Center",
scrollPane); outTextGrafic.setEditable(false); outTextGrafic.append("Pentru oprire
introduceti '.' si <Enter>\n\n"); final JTextField inTextGrafic = new JTextField(40); // containerCurent.add("South",
inTextGrafic); // Crearea unui obiect
"ascultator" de "evenimente actionare" // (pe care le trateaza) ActionListener obiectAscultatorActionare
= new ActionListener() { // Tratarea actionarii intrarii de
text public void actionPerformed(ActionEvent
ev) { final String sirCitit = inTextGrafic.getText(); // Citire din intrare inTextGrafic.setText(""); // Golire intrare text outTextGrafic.append("S-a introdus:
"+sirCitit+"\n"); //Scriere in zona vertical.setValue(vertical.getMaximum()
- vertical.getVisibleAmount()); validate(); repaint(); if (sirCitit.equals(new String("."))) System.exit(0); // Conditie oprire }
}; //Inregistrare obiect
"ascultator" de "evenimente actionare" la "obiect
sursa" inTextGrafic.addActionListener(obiectAscultatorActionare); } public static void main(String[] args) { AppletAplicatie
applet = new AppletAplicatie(); //
Applet-ul are rol de panou JFrame frame = new
JFrame(); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); Container containerCurent = frame.getContentPane(); containerCurent.setLayout(new
BorderLayout()); containerCurent.add("Center",
applet); // Applet-ul e inserat in
fereastra applet.init(); // Initializarile grafice ale
applet-ului refolosite frame.pack(); frame.setVisible(true);
//
Fereastra devine vizibila applet.start(); } } |
Programul AppletAplicatie rulat ca aplicatie de sine statatoare:
Programul AppletOrarSaptamanal afiseaza orarul saptamanal al disciplinei LPAI
(in anul universitar 2010-2011), fara detalii privind orele si grupele si fara
a oferi interactivitate.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
import java.applet.Applet; import java.awt.Graphics; import java.util.Calendar; public class AppletOrarSaptamanal
extends javax.swing.JApplet { public void paint(Graphics g) { g.drawString("Duminica nu sunt ore de LPAI.",
20, 25); g.drawString("Luni sunt proiecte de LPAI", 20,
45); g.drawString("Marti sunt laboratoare de LPAI",
20, 65); g.drawString("Miercuri nu sunt ore de LPAI",
20, 85); g.drawString("Joi sunt aplicatii de LPAI", 20,
105); g.drawString("Vineri este curs de LPAI",
20, 125); g.drawString("Sambata nu sunt ore de LPAI",
20, 145);
} } |
Programul AppletOrarInteractiv este o varianta a applet-ului AppletOrarSaptamanal care afiseaza
interactiv orarul saptamanal al disciplinei LPAI, fara detalii privind
orele si grupele, dar oferind interactivitate
prin intermediul unei linii/intrari de text careia ii este atasat si tratat evenimentul de tip actionare (in
acest caz un <enter> dat cand
cursorul este in interiorul liniei/intrarii de text).
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 |
import java.applet.Applet; import java.awt.*; import java.awt.event.*; import javax.swing.*; import java.util.Calendar; public class AppletOrarInteractiv extends javax.swing.JApplet
{ public void init() { // Obtinerea panoului de
continut (content pane) creat de browser pentru // executia appletului (container in care vor fi plasate componentele) Container
containerCurent = this.getContentPane(); // Stabilirea layout-ului
panoului containerCurent.setLayout(new
BorderLayout()); final JTextArea outGrafic = new JTextArea(8,
40); // Zona non-editabila JScrollPane scrollPane = new JScrollPane(outGrafic, JScrollPane.VERTICAL_SCROLLBAR_ALWAYS,
JScrollPane.HORIZONTAL_SCROLLBAR_ALWAYS); final JScrollBar vertical =
scrollPane.getVerticalScrollBar(); containerCurent.add("Center",
scrollPane); outGrafic.setEditable(false); outGrafic.append("Introduceti 2 pentru a obtine
orarul de luni.\n" + "Introduceti
3 pentru a obtine orarul de marti.\n" + "Introduceti
4 pentru a obtine orarul de miercuri.\n" + "Introduceti
5 pentru a obtine orarul de joi.\n" + "Introduceti
6 pentru a obtine orarul de vineri.\n" + "Introduceti
7 pentru a obtine orarul de sambata.\n" + "Introduceti
1 pentru a obtine orarul de duminica.\n"); final JTextField inGrafic = new JTextField(40);
//
Camp editabil intrare containerCurent.add("South",
inGrafic); // Crearea unui obiect "ascultator" de "evenimente
actionare" // (pe care le trateaza) ActionListener obiectAscultatorActionare = new ActionListener()
{ // Tratarea actionarii
intrarii de text public void actionPerformed(ActionEvent
ev) { String rez; final String sirCitit = inGrafic.getText(); //
Citire din intrare try { int numarZi = Integer.parseInt(sirCitit); switch (numarZi) { case 1: rez = "Duminica nu sunt ore de LPAI.";
break; case 2: rez = "Luni sunt proiecte de LPAI";
break; case
3: rez = "Marti sunt
laboratoare de LPAI."; break; case 4: rez
= "Miercuri nu sunt ore de LPAI.";
break; case 5: rez = "Joi sunt aplicatii de LPAI.";
break; case 6: rez =
"Vineri este curs de LPAI.";
break; case 7: rez = "Sambata nu sunt ore de LPAI.";
break; default: rez="Numarul e prea mare sau negativ. Mai incercati."; } } catch
(NumberFormatException ne) { rez = "Nu ati
introdus un numar. Mai incercati."; } inGrafic.setText(""); // Golire intrare text outGrafic.append(rez + "\n"); //
Scriere in zona vertical.setValue(vertical.getMaximum()-vertical.getVisibleAmount()); validate(); repaint(); } }; //Inregistrare
"ascultator" de "evenimente actionare" la
"sursa" acestora inGrafic.addActionListener(obiectAscultatorActionare); } } |
Se va dezvolta
(concepe, edita, compila si executa in NetBeans IDE) un program Java sub
forma de applet numit AppletOrarInteractivDetaliat care sa permita
afisarea interactiva a orarului la una dintre disciplinele din acest semestru,
cu urmatoarele specificatii:
- organizarea programului va fi similara programului AppletOrarInteractiv in sensul ca interactivitatea va fi realizata prin intermediul unei linii/intrari de text careia ii este atasat si tratat evenimentul de tip
actionare,
- fiecare grup de 2 studenti ai unei subgrupe
(cei 2 studenti care lucreaza la acelasi calculator in cadul laboratorului)
isi va alege o alta disciplina pentru
care sa realizeze orarul (care va trebui sa corespunda celui real din acest semestru),
- spre deosebire de programul AppletOrarInteractiv noul program va permite aflarea orarului
detaliat (incluzand orele de desfasurare) la respectiva disciplina, si
personalizat pentru grupa si subgrupa din care fac parte studentii care il
realizeaza,
- adaptarea
applet-ului pentru a putea rula si ca
aplicatie de sine statatoare (vezi exemplul applet-ului AppletAplicatie).
Temele vor
fi predate la lucrarea urmatoare,
cate un exemplar pentru fiecare grup de
2 studenti, pe hartie (avand numele celor doi studenti scrise pe
prima pagina sus), fie scrise de mana,
fie sub forma de listing.
Adaugarea in applet-ul realizat la tema1 a altor
elemente grafice:
1. buton cu
rol echivalent unui <enter> dat
cand cursorul este in interiorul
liniei/intrarii de text;
2. utilizarea
unor componente de tip radioButton ca alternativa la linia/intrarea de text.
Vezi si detalii
privind interfetele grafice swing in
Java.
1.1. Se lanseaza netbeans-6.1-windows.exe,
1.2. Se confirma TOATE optiunile implicite!!
1.3. Cand se cere specificarea kitului Java se
selecteaza:
C:\Program Files\Java\jdk1.5.0_12