1 Prezentarea platformei Eclipse

1.1 Crearea şi rularea programelor Java cu ajutorul platformei Eclipse

Eclipse este o platformă multi-scop pentru dezvoltarea de software, scrisă, în mare parte, în
limbajul Java, astfel putând rula pe orice sistem de operare actual. Oferă un mediu integrat
de dezvoltare (IDE – Integrated Development Environment) pentru diverse limbaje de
programare (Java , C/C++, PHP, Python, Perl, Cobol). Baza codului sursă provine din
platforma VisualAge dezvoltată de IBM, astfel se explică suportul primit din partea acestei
companii. Platforma Eclipse se încadrează în categoria programelor gratuite şi open source.
Cea mai recentă versiune, Eclipse Neon (v. 4.6), poate fi descărcată de pe site-ul oficial
www.eclipse.org, de la adresa: https://www.eclipse.org/downloads/, Download Packages
(https://eclipse.org/downloads/eclipse-packages/), link-ul Eclipse IDE for Java Developers.
Printre facilitățile platformei Eclipse merită a fi menționate:
• crearea şi gestiunea de proiecte;
• debugging;
• completarea automată a codului (code completion);
• automatizări pentru operații des utilizate (redenumire, creare de set-ere şi get-ere,
completarea automată a secțiunii de import).

1.2 Prezentarea plugin-ului WindowBuilder Pro

WindowBuilder este un designer Java GUI bi-directional puternic şi uşor de utilizat ce face
posibilă crearea cu ușurință a aplicaţiilor Java GUI și permite scurtarea timpului de scriere a
liniilor de cod pentru a genera interfețe utilizator. Cu WindowBuilder se pot crea ferestre
complexe în câteva minute. Folosind designerul vizual, codul Java va fi generat automat. Cu
acest plugin se pot adăuga cu uşurinţă controale cu ajutorul drag-and-drop, se pot adăuga
evenimente pentru controale, se pot modifica proprietăţile diferitelor controale folosind un
editor de proprietăți și multe altele.

WindowBuilder este un plug-in pentru Eclipse și diverse distribuții bazate pe Eclipse IDE
(RAD, RSA, MyEclipse, JBuilder, etc). Acest plug-in construieşte un arbore de sintaxă
abstract (abstract syntax tree - AST) pentru a naviga în codul sursă şi foloseşte GEF
(Graphical Editing Framework) pentru a afişa şi de a gestiona prezentarea vizuală.

Folosind instrumente de aspect WYSIWYG, nu este nevoie să se scrie linii de cod Java
pentru generarea interfețelor - codul va fi generat de WindowBuilder. Codul generat nu are
nevoie de nici o bibliotecă personalizată suplimentară pentru a compila şi rula. Tot codul
generat poate fi utilizat ulterior și fără a fi nevoie ca WindowBuilder să fie instalat în prealabil.
WindowBuilder poate citi şi scrie aproape orice format şi invers, poate converti de cele mai
multe ori cod Java GUI generat manual. Suportă de asemenea editarea oricărei zone de cod
(se pot face modificări oriunde nu numai în unele zone speciale).

Editorul este compus din următoarele componente principale de interfaţă cu utilizatorul:

- Design View - zona principală de aspect vizual.
- Source View – zona de scriere de cod şi de revizuire a codului generat
- Structure View - compus din Component Tree și Property Pane.
o Component Tree - arată relaţia ierarhică între toate componentele.
o Property Pane - afişează proprietăţi şi evenimente ale componentelor
selectate.

1
 - Palette - oferă acces rapid la setul de instrumente specifice componentelor.
- Toolbar - oferă acces la comenzile utilizate frecvent.
- Context Menu - oferă acces la comenzile utilizate frecvent.

Editorul oferă, de asemenea, următoarele caracteristici principale:

- de generare de cod bi-directional - poate citi şi scrie aproape orice format şi invers,
poate converti de cele mai multe ori cod generat manual
- Internationalization (i18n) / Localization - externalizează șiruri de componente,
creează şi gestionează pachete de resurse.
- Custom Composites & Panels – permite crearea de componente personalizate,
reutilizabile.
- Factories – permite crearea de clase şi metode factory personalizate.
- Moştenire vizuală - poate crea ierarhii de componente vizuale.
- Manipulare de evenimente – adaugă evenimente la componente.
- Editor de meniuri - creează şi editează vizual menubars, elemente de meniu şi
meniurile pop-up.
- Morphing – convertește un tip de componentă în altul.

1.3 Instalarea platformei Eclipse

Se presupune că există deja instalata o versiune actualizată de JDK (Java Development Kit)
pe mașina locală.
Instalarea platformei Eclipse se poate face urmărind câțiva pași simpli:
1. Se accesează pagina de download http://www.eclipse.org/downloads/ și se identifica
ultima versiune de Eclipse lansată.
2. Eclipse este disponibilă în mai multe pachete, fiecare specializată pe un anumit tip de
dezvoltare, în funcție de limbajul de programare folosit sau de tipul de aplicație ce
urmează a fi dezvoltat. Dintre aceste pachete noi vom alege ”Eclipse Classic” sau
”Eclipse IDE for Java Developers”
3. Se va descărca versiunea corespunzătoare sistemului de operare folosit pe mașina
locală (Windows 32-bit, 64-bit, Mac, Linux). Pentru descărcare exista o versiune .zip,
sau o versiune cu installer, pe care însă nu o recomand.
4. După ce s-a încheiat descărcarea completă a fișierului .zip, se va alege un director în
care va fi instalat Eclipse. Poate fi de exemplu: C:/Programs/. În acest director se va
dezarhiva Eclipse.
5. Lansarea platformei se face accesând fișierul eclipse.exe aflat în directorul în care s-
a instalat Eclipse.

1.3.1 Instalarea plugin-ului WindowBuilder Pro

Pentru a crește productivitatea în crearea de interfețe utilizator putem folosi WindowsBuilder

Pro, un plug-in visual puternic, susținut și dezvoltat de Google.
Instalarea acestui plug-in se poate face urmărind pașii descriși la linkul de mai jos:
http://help.eclipse.org/kepler/index.jsp?topic=/org.eclipse.wb.doc.user/html/installation/index.
html

Pentru instalarea plugin-ului WindowBuilder Pro în Eclipse Neon se pot parcurge următorii
pași:
1. Se alege din meniul Eclipse Help -> Install New Software…
2. La opțiunea Work with: se va selecta
Neon - http://download.eclipse.org/releases/neon
3. În secțiunea Type filter text introduceți textul WindowBuilder

2
 4. Plugin-ul se regăsește în pachetul Gerneral Purpose Tools. Aici de identifică
componentele WindowBuidler.
5. Se selectează toate aceste componente și se apasă Finish.

Ca soluție alternativă se poate adăuga la pasul 2 din lista de pași de mai sus un link de
download pentru WindowBuilder. Acest lucru se poate realiza apăsând butonul Add… . În
fereastra ce apare se selectează un nume (de exemplu WindowBuilder Pro), iar la Localtion
se va selecta din pagina de mai jos linkul de download corespunzător versiunii eclipse
instalată:
http://www.eclipse.org/windowbuilder/download.php

1.4 Interfața de lucru a platformei Eclipse

Mediul de lucru al celor mai populare editoare folosesc următoare structură ierarhică:

|_ Workspace – directorul rădăcină unde vor fi salvate proiectele

|_ Project – directorul specific unui singur proiect ce va conține fișierele sursă
|_Folders – director sau structură de directoare
|_ File – fișier ce conține codul sursă

Un Workspace conține în general un set de proiecte ce pot conlucra între ele, sau sunt
relaționate într-un fel. Un workspace poate conține astfel mai multe proiecte.
Un Project conține un set de fișiere sursă sau diferite resurse (poze, icons, pachete java)
necesare rulării proiectului. Un proiect poate fi privit ca o aplicație unitară de sine stătătoare,
unde fișierele aflate în componența sa sunt într-o strânsă legătură. Un proiect poate conține
deci mai multe fișiere.
Un fișier reprezintă cea mai mică entitate dintr-un proiect și în cele mai multe cazuri conține
cod sursă.

La pornirea mediului Eclipse este cerută calea unui director care va reprezenta spațiul de
lucru al platformei (workspace). Aici se vor putea salva proiectele, fișierele, resursele și
toate datele necesare rulării proiectelor dezvoltate.

După alegerea directorului pentru workspace se va încărca fereastra Eclipse implicită

(Welcome). În această pagină se găsesc referințe către tutoriale de folosire a platformei
Eclipse.

3
După închiderea ferestrei de Welcome se va încărca interfața de lucru Eclipse.

4
Ferestrele vizibile din interfața Eclipse sunt grupate logic în perspective. O perspectivă indică
numărul de ferestre vizibile, poziția lor și opțiunile vizibile în aceste ferestre, în funcție de
limbajul utilizat în proiectul deschis. Prin instalarea de noi plug-in-uri se pot adăuga noi
perspective. Perspectiva curentă se poate schimba de la butoanele dedicate situate în
partea dreaptă‐sus a workbench‐ului Eclipse.
În printscreen-ul de mai jos este selectată perspectiva Java. Sunt prezentate de asemenea
ferestrele vizibile din perspectiva Java și semnificația lor.

5
 Controlul perspectivei

Editorul de cod sursă

Package explorer
- proiectele din spațiul de lucru
- pachetele și fișierele proiectului
- librării incluse în proiect Outline
- alte resurse asociate proiectului - structura clasei / claselor din fișierul
deschis in editor (câmpuri, constructori,
metode)

Console
- Rezultatul execuției programelor

1.5 Crearea unui proiect în Java

După ce a fost selectat workspace-ul și a fost închisă fereastra de Welcome s-a încărcat
interfața de lucru Eclipse cu perspectiva Java. Workspace-ul însa nu conține nici un proiect.
Acesta va trebui creat.

Adăugarea unui proiect nou se face din meniul File -> New. Eclipse permite crearea mai
multor tipuri de proiecte. Dintre cele disponibile vom alege ”Java Project” dacă dorim crearea
unei aplicații Java clasice simple.

6
În următorul screen ni se cere introducerea numelui proiectului. După cum se observă, pe
măsură ce este introdus numele proiectului în calea worspace-ului, acesta apare ca și
director.

7
În mod implicit pentru un proiect este creată următoarea structură de directoare:
<directorul_selectat_pentru_workspace>
|_ TestProject
|_ bin
|_ src

Această structură de directoare se găsește în directorul selectat pentru workspace la

pornirea platformei Eclipse.
TestProject este numele proiectului. Odată cu crearea unui proiect se creează și un director
cu același nume cu al proiectului.
În directorul src vor fi adăugate fișierele sursă ale aplicației.
Directorul bin va fi folosit de Eclipse pentru generarea în interiorul lui a codului mașină
compilat din codul sursă preluat din directorul src.

1.6 Adăugarea codului sursă la un proiect

1.6.1 Adăugarea unei clase noi la proiect

După crearea unui proiect nou, se pot adăuga fișierele ce conțin codul sursă. Clasele într-un
proiect sunt adăugate în directorul src. Este recomandată folosirea pachetelor (package)
pentru seturi de clase cu funcționalități asemănătoare.
Adăugarea se face în felul următor:
1. Mouse dreapta pe directorul src
2. Din meniul contextual ce apare se selectează New și apoi Class

3. În fereastra nou apărută se vor introduce pe rând numele pachetului și numele clasei.

8
 4. Daca se dorește crearea unei clase ce conține metoda main, se va bifa opțiunea
corespunzătoare. Metoda main va fi automat generată la crearea clasei.
5. La final se apasă butonul Finish.

Din printscreen-ul de mai sus se pot observa următoarele:

- În directorul src a fost creat un nou director ce a luat numele pachetului fișierului nou
creat, tests.

9
 - În directorul tests a fost creat fișierul TestClass.java
- Fișierul nou creat este deschis automat în editorul de cod.
- Bifând opțiunea de creare a metodei main se observă din cod că aceasta a fost
automat generată.
- În partea dreaptă a perspectivei curente se observă că în fereastra Outline au apărut
deja numele clasei și metoda main.

1.6.2 Adăugare unei clase noi la proiect folosind WindowBuilder Pro

Dacă instalarea plugin-ului WindowBuilder Pro a fost realizată cu succes, atunci pentru
adăugarea unei clase noi într-un proiect se pot urma următorii pași:

1. Ca și în cazul adăugării unei clase simple, vom da click dreapta pe directorul src
2. Din meniul contextual ce apare se selectează New și mai apoi opțiunea Other…
3. Dacă plugin-ului WindowBuilder Pro s-a instalat corect ar trebui să existe setul de
Wizard-uri WindowBuilder.

4. Din lista disponibilă se va alege Designerul dorit. Pentru exemplificare vom alege
JFrame.
5. La pasul următor se cere introducerea numelui pachetului și numelui clasei
6. La final se apasă butonul Finish.

Rezultatul se poate analiza în printscreen-ul de mai jos.

Aici remarcăm următoarele:
- În directorul src a fost creat un nou subdirector, ui, ce reprezintă numele pachetului
clasei nou create TestJFrame.
- Un nou fișier sursă a fost creat, TestFrame.java, corespunzător clasei cu același
nume, însă de data aceasta cu o structură mai complexă.
- Structura fișierului nou creat se observă foarte bine în fereastra Outline (dreapta)
- Un lucru esențial de remarcat este apariția în partea de jos a Editorului de cod a două
tab-uri, Source și Design

10
Cu ajutorul celor două tab-uri Source și Design se poate face foarte rapid trecerea din mediul
visual în cod sursă și invers. În urma modificărilor făcute în oricare din cele două medii
efectul apare imediat în celălalt mediu.

Toolbar

Component Tree

Palette
Design View
Instrumente
specifice
componentelor
Property Pane

11
1.7 JFrame vs. Application Window

12
13
Comparație între codul generat pentru un JFrame și cel generat pentru un Application
Window

package ui; package ui;

import java.awt.BorderLayout; import java.awt.EventQueue;

public class TestJFrame extends JFrame { public class NewApp {

private JPanel contentPane; private JFrame frame;

/** /**
* Launch the application. * Launch the application.
*/ */
public static void main(String[] args) { public static void main(String[] args) {
EventQueue.invokeLater(new Runnable() { EventQueue.invokeLater(new Runnable() {
public void run() { public void run() {
try { try {
TestJFrame frame = new NewApp window = new NewApp();
TestJFrame(); window.frame.setVisible(true);
frame.setVisible(true); } catch (Exception e) {
} catch (Exception e) { e.printStackTrace();
e.printStackTrace(); }
} }
} });
}); }
}
/**
/** * Create the application.
* Create the frame. */
*/ public NewApp() {
public TestJFrame() { initialize();
}
setDefaultCloseOperation(JFrame.EXIT_ON_CLO
SE); /**
setBounds(100, 100, 450, 300); * Initialize the contents of the frame.
contentPane = new JPanel(); */
contentPane.setBorder(new private void initialize() {
EmptyBorder(5, 5, 5, 5)); frame = new JFrame();
contentPane.setLayout(new frame.setBounds(100, 100, 450, 300);
BorderLayout(0, 0));
setContentPane(contentPane); frame.setDefaultCloseOperation(JFrame.EXIT_
} ON_CLOSE);
}
}
}

14
15
Mai jos este listat codul sursă generat pentru interfața din printscreen-ul de mai sus. Butonul
New Button are un evet handler (acultător de evenimente), metoda addActionListener(), cu
ajutorul căruia la apasarea butonului se schimbă textul etichetei lblNewLabel.
package ui;

import java.awt.EventQueue;

public class NewApp {

private JFrame frame;

JLabel lblNewLabel;

/**
* Launch the application.
*/
public static void main(String[] args) {
EventQueue.invokeLater(new Runnable() {
public void run() {
try {
NewApp window = new NewApp();
window.frame.setVisible(true);
} catch (Exception e) {
e.printStackTrace();
}
}
});
}

/**
* Create the application.
*/
public NewApp() {
initialize();
}

/**
* Initialize the contents of the frame.
*/
private void initialize() {
frame = new JFrame();
frame.setBounds(100, 100, 450, 300);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

lblNewLabel = new JLabel("New label");

frame.getContentPane().add(lblNewLabel, BorderLayout.SOUTH);

JButton btnNewButton = new JButton("New button");

btnNewButton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent arg0) {
lblNewLabel.setText("The button was pressed.");
}
});
frame.getContentPane().add(btnNewButton, BorderLayout.NORTH);
}

1.8 Bibliografie

http://code.google.com/intl/ro-RO/javadevtools/wbpro/index.html

16