Lucrarea nr.

7
1. Faza de Colectare a Cerinţelor.

Scopul lucrării

În timpul fazei de specificare a cerinţelor softiştii trebuie

să ştie exact ce produs doreşte clientul, dar cum majoritatea
clienţilor nu sunt specialiştii în calculatoare, ei trebuie să
stabilească de ce anume are nevoie clientul.
1.1. Analiza cerinţelor tehnice

Analiza cererilor începe cu întâlnirea dintre membrii

echipei de soft şi clienţi. Interviurile durează până când echipa
softiştilor consideră că are informaţii suficiente despre client şi
despre viitorii utilizatori ai produsului.
Sunt două tipuri de interviuri: structurate şi nestructurate.
Cele structurate “close-ended” iar cele nestructurate de tipul
“open-ended” în care clientul este întrebat despre produsul
actual de ce este nesatisfăcator.
O altă cale în a strânge informaţii necesare, este prin a
trimite clientului un formular tehnic pentru completare.
O cale mai nouă de a obţine informaţii, de a vedea exact ce
se face, este prin a monta o camera video în locurile de muncă.
Această tehnică este destul de delicată, pentru că prezenţa
camerei la locul de muncă trebuie să fie acceptată de angajaţi şi
nu luată ca o încălcare nejustificată a intimităţi.
Scenariul este o altă tehnică de analiză a cererilor. Spre
exemplu, dacă produsul este un planificator al greutăţii
corporale, (proiect de slăbire) atunci programul, conform unor
date pe care le introducem (înălţime, greutate, vârsta, etc.) ne va
oferi informaţii utile despre module de alimentaţie, aceste
informaţii tipărite pot fi modificate în funcţie de cerinţele
utilizatorului. Astfel cererile clienţilor sunt transmise direct
proiectantului.
Un scenariu poate fi descris în multe feluri, o tehnică este
folosirea diagramelor care descriu secvenţa de evenimente (acest
mod poate utiliza un format standard) sau, o altă tehnică este
utilizarea unui arbore de evenimente în care fiecare mod
prezintă acţiunile posibile pe care trebuie să le facă utilizatorul
la momentul respectiv în scenariu.
Dar cea mai puternică tehnică de analiza a cerinţelor este
prototipizarea rapidă.

1.2. Prototipizarea rapidă

Prototipizarea rapidă construieşte softul care dovedeşte

toate funcţionalităţile produsului final.
Acest model este interfaţa de lucru cu noul produs. În
timpul testării se afla acolo o echipă de la softişti care urmăresc
şi îşi iau notiţe. În această perioadă clientul îşi spune părerea
despre produs, iar în cazul în care cele două parţi au ajuns la
concluzia că e necesar se vor face şi schimbări.
Un aspect important al prototipizării rapide este ca şi
clienţii şi softiştii să ajungă să răspundă la întrebare ce produs
trebuie făcut.
Al doilea aspect este ca modelul să fie construit astfel încât
să poată fi modificat.
Prototipizarea rapidă este utilă atunci când se creează
interfaţa utilizator pentru produs.

1.3. Factorul uman

Este important ca atât clientul cât şi utilizatorul produsului

să interacţioneze cu interfaţa utilizator a prototipului rapid.
Scopul principal al acestei interacţiuni numită şi "human
computer interface" (HCI), este de a dezvolta un produs care să
fie “user friendly” adică uşor de învăţat pentru folosire, practic
şi rapid.
În zilele noastre interfaţa cu utilizatorul este construită
folosind elemente de grafică cum ar fi ferestre, icoane şi
butoane.
 Oricum chiar dacă produsul final foloseşte tehnologie
modernă nu trebuie să se uite niciodată faptul că produsul final
este făcut pentru a fi utilizat de către om, deci trebuie acordată
importanţă factorului uman.
Câteodată o interfaţă grafică nu poate mulţumi toate
tipurile de utilizatori, adică dacă avem un profesionist în
calculatoare şi un utilizator din liceul cu experienţă în lucru,
este preferabil să se creeze pentru ambele tipuri de utilizatori
interfeţe grafice diferite implicând factorul uman.
Este preferabil ca la creerea unui proiect, interfaţa cu
utilizatorul să se bazeze pe puterea de deducţie a utilizatorului,
folosind astfel ideea creerii unei interfeţe care seamănă cu ceva
văzut înainte. Acest lucru a fost folosit de proiectanţi de la
MacInthosh şi a dus la o utilizare foarte uşoară a produselor
respective.

1.4. Prototipizarea rapidă ca o specificaţie tehnică

Rolul prototipizării rapide este de a determina cerinţele

clientului şi este utilizată până la semnarea de către client a
specificaţiei tehnice.
Este recomandat ca prototipul rapid să nu ia locul
specificaţiei scrise datorită problemelor şi discuţiilor ulterioare
care pot să apară între client şi dezvoltatori în cazul lipsei unei
specificaţii scrise. În cazul modificărilor efectuate în prototipul
rapid echipa de softişti trebuie să realizeze modificările şi în
documentaţie.
Singura excepţie admisă este cazul în care clientul şi
dezvoltatorul sunt una şi aceeaşi persoană.
Figurile următoare ilustrează folosirea prototipului rapid,
în prima figură (Fig. 7.4-1) ca model individual iar în a doua
servind ca specificaţie tehnică (Fig. 7.4-2).
 Prototip rapid Schimbări cerute

Verificare Verificare

Specificaţie

Verificare

Planificare

Verificare

Design

Verificare

Implementare

Testare

Integrare

Testare

Mod operare

Dezvoltare
Retragere
Mentenanţă

Fig. 1.4-1 Modelul prototipizării rapide

 Prototip rapid Schimbări cerute

Verificare Verificare

Planificare

Verificare

Proiectare

Verificare

Implementare

Verificare

Integrare

Testare

Mod operare

Retragere
Dezvoltare
Mentenanţă

Fig. 1.4-2Prototipizarea rapidă cu prototipul rapid servind

ca şi specificaţie

1.5. Reutilizarea prototipului rapid

Rolul prototipului rapid este crearea unui produs final

complet acest lucru se face prin prelucrarea (modificarea)
prototipului rapid până ce se obţine produsul dorit.
O utilizare diferită a prototipului rapid este prezentată prin
exemplul următor. În 1988 firmele Blaire, Murphy, Schach şi
McDonald doreau un sistem informaţional de management.
Autorul a adoptat în acest caz folosirea prototipului rapid
deoarece erau 6 domenii de activitate diferite, modulul principal
era unul singur dar trebuiau făcute câteva modificări pentru
fiecare domeniu, aceste modificări erau minime prin folosirea
prototipului rapid.

1.6. Implicaţiile manageriale ale prototipului rapid

O problemă a prototipului rapid este aceea că, cu cât se pot

face schimbări rapide în prototip cu atât clientul este încurajat să
modifice cât mai mult şi cât mai repede. Astfel schimbările
trebuiesc făcute urmând o cuantă de timp.
Orice manager trebuie să ia în considerare două aspecte
importante a prototipului rapid: primul este că, prototipul trebuie
să detecteze cerinţele clientului iar al doilea trebuie să ţină
seama că, chiar dacă în anumite circumstanţe el poate lua locul
specificaţiei scrise el niciodată nu poate înlocui faza de design a
proiectului.
O altă imagine importantă a prototipului rapid este aceea
că schimbă imaginea managerului care era obişnuit cu a finaliza
un produs bine la prima realizare. El are conceptul de "feedback
loop" care se referă la revenirile care trebuiesc făcute asupra
prototipului.
Un alt aspect al prototipului rapid este că el creşte numărul
interacţiunilor dintre client şi dezvoltatori, de fapt în această
fază ei sunt într-o continuă interacţiune.

1.7. Experienţa cu prototipul rapid

Gordon şi Bieman au analizat 39 de cazuri publicate şi

nepublicate ale prototipului rapid [Gordon şi Bieman, 1995].
Dintre acestea 33 au fost considerate un succes, 3 nereuşite şi 3
nu au fost clarificate.
Ei consideră că munca lor a scos la iveală faptul că un
număr de proiecte soft au folosit cu succes prototipul rapid.
1.8. JAD (Joint application design)

Este o fază mai evaluată a prototipului rapid unde clientul

joacă un rol mai important.
JAD este o tehnică în care echipa de dezvoltatori şi clientul
lucrează ca o echipă şi îşi asumă responsabilităţile pentru
produsul final.

1.9. Compararea tehnicilor de analiză a cerinţelor

Prima tehnică de analiză a cererilor este inteviul. Rolul

acestui interviu este de a determina cât mai clar cu putinţă
cererile clienţilor în legătură cu produsul, aceste informaţii vor
folosi în realizarea prototipului rapid. Dar cea mai bună tehnică
de analiză rămâne prototipul rapid. Este potrivit ca orice
combinaţie a tehnici de analiză a cerinţelor să includă interviul.
În plus nefolosirea tehnicilor cum ar fi prototipul rapid sau JAD
este un risc pe care îl va avea acea fază de analiză a cerinţelor de
a nu detecta clar toate problemele clientului.

1.10.Testarea în timpul fazei cerinţelor

Rolul fazei cerinţelor este de a stabili adevăratele cerinţe

ale clientului, de obicei nu clientul va fi principalul utilizator al
produsului. Deci este benefic să se dea posibilitatea utilizatorilor
să testeze şi să-şi spună părerea despre produs.
Grupul care asigură calitatea software-lui, SQA (Software
Quality Assurance), în timpul fazei de prototipizare rapidă, are
rolul de a asigura faptul ca membri relevanţi ai clientului să aibă
oportunitatea de a interacţiona cu prototipul rapid şi ca sugestiile
lor să ajungă la client sau eventual la comitetul de manageri ai
clientului responsabili pentru analizarea sugestiilor utilizatorilor.
1.11.Unelte CASE pentru faza cerinţelor

Limbajele interpretate se folosesc în general ca medii

pentru prototipizarea rapidă, deoarece limbajele interpretate nu
au nevoie să fie compilate sau linkeditate, astfel dezvoltarea
prototipului este rapidă.
Ca exemplu putem aminti Unix shell care este folosit din
ce în ce mai mult pentru construirea unor prototipuri rapide. Un
al limbaj de prototipizare rapidă folosit pe scară largă este
Hypertext-ul.
Pentru prototipizarea rapidă a interfeţei cu utilizatorul
două dintre cele mai cunoscute utilitare CASE sunt DEMO II şi
GUIDE.
O tendinţă recentă este răspândirea utilizării limbajelor de
generaţia a patra (4GL), cum ar fi FOCUS, INTOMIX,
NATURAL, NOMAD şi POWERHOUSE.
Procesul software recomandat pentru 4GL este construirea
unui prototip rapid şi apoi rafinarea acestuia până la forma
finală. Această abordare riscă să se degenereze în modelul
"build-and-fix" adică construieşte şi repară.

1.12.Metrici pentru faza cerinţelor

În timpul construirii prototipului rapid elementele de

fiabilitate sau alte statistici calitative şi cantitative nu sunt
importante, importanţa cea mai mare o are timpul în care
prototipul rapid determină cerinţele clientului şi mai are rolul
ţinerii evidenţei numărului de schimbări aduse în această
perioadă de timp.
Conform statisticilor dacă în timpul prototipizării rapide s-
au făcut un număr mare de schimbări este indicată o analiză
atentă a fazei de specificare a cerinţelor.
1.13.MSG studiu de caz : faza de specificare a
cerinţelor

Când Martha Stockton Greengage a murit la vârsta de 87

de ani şi-a lăsat 2 milioane $ pentru caritate, creând astfel
fundaţia Martha Stockton Greengage (MSG), pentru a ajuta
tinerii să-şi obţină propria locuinţă.
MSG pentru a reduce cheltuielile de operare a hotărât
implementarea unui program computerizat. Deoarece nici unul
din membri nu aveau cunoştinţe în domeniul computerelor au
stabilit să discute cu o echipă de softişti să implementeze un
proiect pilot. Pentru aceasta membri echipei de dezvoltare
intervievează diferiţi manageri MSG şi alţi lucrători pentru a
descoperi modul de lucru al fundaţiei. MSG oferă o ipotecă de
100% pentru cumpărarea unei case în următoarele condiţii:
1. Cuplul trebuie să fie căsătorit de cel puţin 1 an dar nu
mai mult de 10.
2. Ambii soţi trebuie să aibe un loc de muncă.
3. Preţul casei trebuie să fie sub preţul mediu publicat
pentru casele din aceea zonă pentru ultimele 12 luni.
4. Rata pentru o ipotecă de 90% pe 30 ani ar depăşi 28%
din câştigurile combinate şi/sau cuplul nu are suficiente
depozite pentru a plăti 10% din costul casei plus 7000$
(alte costuri).
5. Dacă fundaţia are suficiente fonduri pentru a cumpăra
casa.

Dacă aplicaţia este aprobată cuplul trebuie să plătească

MSG-ului în fiecare săptămână timp de 30 de ani o sumă
calculată astfel:
1. Rata care trebuie plătită este de 1/1560 din preţul de
cumpărare al casei.
2. Dobânda care este 1/52 din 4% a balanţei curente a
ipotecii.
3. Taxa pe proprietate care este 1/52 din suma taxei de
proprietate anuale şi a asigurări anuale.
 4. Suma totală care trebuie plătită săptămânal este suma
valorilor de la 1, 2, 3.
5. Dacă valoarea de la 4 este mai mare decât 28% din
venitul săptămânal al cuplului atunci MSG va plăti
diferenţa sub forma unei burse.

Cuplul trebuie să facă dovada câştigurilor şi a taxelor în

fiecare an.
MSG determină dacă are fondurile necesare aprobării unei
ipoteci în următorul mod:
1. La începutul fiecărei săptămâni se calculează venitul
anual prognozat, din investiţii, şi acesta este împărţit la
52.
2. Cheltuielile anuale prognozate sunt împărţite la 52.
3. Se calculează totalul plăţilor pentru săptămâna
respectivă.
4. Se calculează totalul împrumuturilor prognozate pentru
săptămâna respectivă.
5. Deci suma disponibilă este (1) - (2) + (3) - (4)
6. Dacă costul casei nu este mai mare decât (5), atunci
există fondurile necesare pentru cumpărarea casei.
7. La sfârşitul săptămânii, orice fonduri necheltuite sunt
reinvestite.

Pentru a ţine costul proiectului pilot cât mai mic cu putinţă

softişti au stabilit să introducă doar tipurile de date strict
necesare, şi anume: date despre investiţie, cheltuieli de operare,
date despre ipoteci. În această primă fază nu este important să se
incorporeze acţiunile necesare în cazul în care clienţii nu reuşesc
să îşi facă plata săptămânală, deoarece această situaţie s-a
dovedit a fi infrecventă.

Pentru investiţii următoarele date sunt necesare:

 Identificator (12 cifre)
 Denumire
  Beneficiul anual prognozat (max. $999,999,999.99) -
actualizat de fiecare dată când există informaţii
disponibile, dar de obicei de aproximativ cinci ori pe an.
 Data la care a fost actualizat beneficiul anual prognozat.

Pentru cheltuielile de operare sunt necesare următoarele

date:
 Cheltuielile anuale prognozate (max. $999,999,999.99)
- acestea sunt calculate de patru ori pe an.

Pentru fiecare ipotecă avem următoarele date:

 Cont (12 cifre)
 Numele clientului
 Preţul original de cumpărare al casei (max.
$999,999,999.99)
 Data la care a fost eliberată ipoteca
 Veniturile săptămânale curente combinate (max.
$999,999,999.99)
 Data la care veniturile săptămânale combinate au fost
actualizate.
 Taxa anuală pe proprietate (max. $99,999.99)
 Asigurarea anuală (max. $99,999.99)
 Balanţa ipotecii (max. $999,999,999.99)

Sunt necesare rutine pentru introducere, modificare şi

ştergere a datelor privind investiţiile, ipoteca şi cheltuielile de
operare, de asemenea rutine folosite pentru calculul săptămânal
al fondurilor disponibile. Mai sunt necesare şi trei tipuri de
rapoarte: listarea tuturor investiţiilor, listarea tuturor ipotecilor şi
a câtorva rezultate săptămânale.

1.14.MSG studiu de caz : prototipul rapid

Chiar dacă procesul de colectare a cerinţelor s-a desfăşurat

cu o mare grijă, pentru a determina ca produsul final să
întrunească cerinţele clienţilor şi ale utilizatorilor este indicată
crearea unui prototip rapid. Pentru aceasta s-a folosit limbajul de
programare Java.
Codul prototipului, prezentat mai jos, este uşor de înţeles.
Cu toate acestea există trei aspecte de discutat. În primul rând,
investiţiile sunt stocate într-un tablou portofolio cu elemente de
tipul InvestmentRecord. În produsul final această structură ar
trebui înlocuită cu una care să permită un număr variabil de
investiţii.
Al doilea aspect important este acela că nu este terminat.
De exemplu doar raportul de investiţii poate fi tipărit. Unele
dintre metode, cum ar fi: addMortgage, modifyMortgage,
deleteMortgage, prezintă doar interfaţa de apel şi afişează un
mesaj la apelare. Aceasta deoarece operaţiile asupra investiţiilor
şi ipotecii sunt foarte similare, astfel că dacă pentru investiţii se
realizează o funcţionalitate completă, aceasta ar putea fi folosită
şi pentru ipoteci.
În final, interfaţa utilizator este realizată prin meniuri şi nu
folosind o interfaţă grafică. Pentru realizarea prototipului rapid,
dacă nu sunt la îndemână unelte de generare a interfeţelor
grafice, atunci se recomandă folosirea meniurilor.

import java.io.*;
import java.util..*;

/
***************************************************
************************
*
* Clasa InvestmentRecord
*
/
***************************************************
***********************/

class InvestmentRecord {
public String number;
public String name;
 public float ret;
public Date date;
} // InvestmentRecord

/
***************************************************
************************
*
* Clasa MSGPrototypeApplication
*
/
***************************************************
***********************/

class MSGPrototypeApplication {
public static void main (String args[]) {
MSGPrototype thisApplication = new
MSGPrototype ();

thisApplication.initialize ();
thisApplication.clearScreen ();
thisApplication.mainMenu ();
} // main

} // MSGPrototypeApplication

/
***************************************************
************************
*
* Clasa MSGPrototype
*
/
***************************************************
***********************/

class MSGPrototype {
 public static final int NUM_RECORDS = 11;

public InvestmentRecord portfolio[] = new

InvestmentRecord[NUM_RECORDS];

/
***************************************************
************************
*
* Fiindcă aceasta este un prototip rapid o matrice de
înregistrări au fost utilizate.
* În implementarea finală va fi necesară o structură de date
dinamică,
* fiindcă nu este clar câte investiţii vom avea.
*
/
***************************************************
***********************/

public void clearScreen (){

//
// Clear the screen
//
//
// cod dependent de implementare pentru şteregerea
ecranului
//
} // clearScreen

//----------------------------------------------------------------------------
-----------------------------------

public void initialize (){

//
// iniţializarea investiţiilor
//
for (int i = 0; i < NUM_RECORDS; i++) {
 portfolio[i] = new InvestmentRecord ();
portfolio[i].number = “000000000000”;
}
} // initialize

//----------------------------------------------------------------------------
-----------------------------------

public void addInvestment (){

//
// permite utilizatorului adăugarea investiţiilor
//
try {
int current = 0;
char c;
boolean found = false;
StringBuffer input;

while (!found || (current == NUM_RECORDS)) {

if (portfolio[current].number.compareTo
(“000000000000”) == 0)
found = true;
else
current++;
}
clearScreen ();

System.out.println (“Enter investment number (12

digits):”);
input = new StringBuffer ();
while ((c = (char) System.in.read ()) != ‘\n’) {
input.append (c);
}
portfolio[current].number = input.toString ();
System.out.println (“Enter name: ”);
input = new StringBuffer ();
while ((c = (char) System.in.read ()) != ‘\n’) {
 input.append (c);
}
portfolio[current].name = input.toString ();

System.out.println (“Enter estimated annual

return:”);
input = new StringBuffer ();
while ((c = (char) System.in.read ()) != ‘\n’) {
input.append (c);
}
Float tempFloat = new Float (input.toString ());
portfolio[current].ret = tempFloat.floatValue ();

portfolio[current].date = new Date();

}
catch (Exception e) {
System.out.println (“addinvestment error:” + e);
}
} // addInvestment

//----------------------------------------------------------------------------
-----------------------------------

public void modifyInvestment (){

//
// permite utilizatorului modificarea investiţiilor
//
try
{
int current;
char c;
byte choice[] = new byte[10];
boolean found;
StringBuffer input;

clearScreen ();
System.out.println(“\n\n”);
System.out.println(“Enter investment number of
investment to be modified: ”);
input = new StringBuffer ();
while ((c = (char) System.in.read ()) != ‘\n’) {
input.append (c);
}
found = false;
current = 0;
while(!found && (current < NUM_RECORDS)) {

if(portfolio[current].number.compareTo(input.toStrin
g())==0)
found = true;
else current = current +1;
}

if (!found)
System.out.println (“Record not found”);
else {
System.out.println (”\n\n”);
System.out.println (” 1. Investment Number
\n”);
System.out.println (” 2. Investment Name \n”);
System.out.println (” 3. Estimated Annual
Ret \n”);
System.out.println (”\n\n”);

System.out.println (” Select field to be

modified”);
System.in.read (choice);

System.out.println (”\n\n”);

switch ((char) choice [0]) {

case ’1’:
System.out.println (”Enter investment number
(12 digits):”);
 input = new StringBuffer ();
while ((c =(char) Sysem.in.read ()) != ’\n’) {
input.append (c);
}
portfolio[current].number = input.toString ();
break;

case ’2’:
System.out.println (”Enter investment
name:”);
input = new StringBuffer ();
while ((c =(char) Sysem.in.read ()) != ’\n’) {
input.append (c);
}
portfolio[current].name = input.toString ();
break;

case ’3’:
System.out.println (”Enter estimated annual
return:”);
input = new StringBuffer ();
while ((c =(char) Sysem.in.read ()) != ’\n’) {
input.append (c);
}
Float tempFloat = new Float (input.toString
());
portfolio[current].ret = tempFloat.floatValue
();
portfolio[current].date = new Date ();
break;
} // switch
} // else
}
catch (Exception e) {
}
} // modifyInvestment
//----------------------------------------------------------------------------
-----------------------------------

public void deleteInvestment () {

//
// permite utilizatorului ştergerea investiţiilor
//
try {
int current;
char c;
boolean found;
StringBuffer input;

clearScreen();

System.out.println (”\n\n”);
System.out.println (”Enter investment # of
investment to be deleted:”);
input = new StringBuffer ();
while((c = (char)System.in.read ()) != ’\n’) {
input.append (c);
}

found = false;
current = 1;
while (!found && (current < NUM_RECORDS)) {

if(portfolio[current].number.compareTo(input.toStrin
g())==0)
found = true;
else
current = current + 1;
}
if (!found)
System.out.println (”Record not found \n”);
else {
portfolio[current].number = new String
(”000000000000”);
 System.out.println (”Record deleted”);
}
}
catch (Exception e) {
}
} // deleteInvestment

//----------------------------------------------------------------------------
-----------------------------------

public void addMortgage (){

//
// permite utilizatorului adăugarea ipotecilor
//
try {
byte c[] = new byte[10];

System.out.println (”Not yet implemented. Press

Enter to continue”);
System.in.read (c);
}
catch (Exception e) {
}
} // addMortgage

//----------------------------------------------------------------------------
-----------------------------------

public void modifyMortgage (){

//
// permite utilizatorului modificarea ipotecilor
//
try {
byte c[] = new byte[10];

System.out.println (”Not yet implemented. Press

Enter to continue”);
 System.in.read (c);
}
catch (Exception e) {
}
} // modifyMortgage

//----------------------------------------------------------------------------
-----------------------------------

public void deleteMortgage (){

//
// permite utilizatorului ştergerea ipotecilor
//
try {
byte c[] = new byte[10];

System.out.println (”Not yet implemented. Press

Enter to continue”);
System.in.read (c);
}
catch (Exception e) {
}
} // deleteMortgage

//----------------------------------------------------------------------------
-----------------------------------

public void mortgageMenu (){

//
// permite utilizatorului selectarea operaţiunilor asupra
informaţiilor de ipotecă
//
try {
byte choice[] = new byte[10];
boolean done = false;

while (!done) {
clearScreen ();

System.out.println (”\n\n\n\n”);
System.out.println (” MORTGAGE
MENU”);
System.out.println (”\n\n”);
System.out.println (” 1.Add Mortgage
data”);
System.out.println ();
System.out.println (” 2.Modify Mortgage
data”);
System.out.println ();
System.out.println (” 3.Delete Mortgage
data”);
System.out.println ();
System.out.println (” 4.Return to Main
Menu”);
System.out.println (”\n\n”);

System.out.println(”Enter your selection and

press <ENTER>”);
System.in.read (choice);

switch((char) choice[0]) {
case ‘1‘:
addMortgage ();
break;

case ‘2‘:
modifyMortgage ();
break;

case ‘3‘:
deleteMortgage ();
break;

case ‘4‘:
 case ‘\n‘:
done = true;
break;

default:
System.out.println (”\n\n”);
System.out.println( ”Incorrect selection, try
again\n”);
break;
} // switch
}
}
catch (Exception e){
}
} // mortgageMenu

//----------------------------------------------------------------------------
-----------------------------------

public void opexpensesMenu (){

//
// permite utilizatorului selectarea operaţiunilor asupra
informaţiilor
// despre cheltuieli de funcţionare
try {
byte c[] = new byte[10];

System.out.println (”Not yet implemented. Press

Enter to continue”);
System.in.read (c);
}
catch (Exception e) {
}
} // opexpensesMenu

//----------------------------------------------------------------------------
-----------------------------------
public void investmentMenu (){
//
// permite utilizatorului selectarea operaţiunilor asupra
informaţiilor de investiţie
//
try {
byte choice[] = new byte[10];
boolean done = false;

while (!done) {
clearScreen ();

System.out.println (”\n\n\n\n”);
System.out.println (” INVESTMENT
MENU\n”);
System.out.println (”\n\n”);
System.out.println (” 1.Add Investment
data\n”);
System.out.println (” 2.Modify Investment
data\n”);
System.out.println (” 3.Delete Investment
data\n”);
System.out.println (” 4.Return to Main
Menu\n”);

System.out.println(”Enter your selection and

press <ENTER>”);
System.in.read (choice);
switch((char) choice[0]) {
case ‘1‘:
addInvestment ();
break;
case ‘2‘:
modifyInvestment ();
break;
case ‘3‘:
 deleteInvestment ();
break;
case ‘4‘:
case ‘\n‘:
done = true;
break;
default:
System.out.println( ”Choice is out of
range”);
break;
}
}
}
catch (Exception e) {
}
} // InvestmentMenu

//----------------------------------------------------------------------------
-----------------------------------

public void InvestmentListing (){

//
// Tipăreşte raportul dspre investiţii
//
try {
byte c[] = new byte[10];

clearScreen ();
System.out.println (”\n\n”);
System.out.println (” INVESTMENTS
REPORT”);
System.out.println (” MARTHA STOCKTON
GREENGAGE
FOUNDATION”);
System.out.println (” Investments Listing”);
System.out.println ();
 System.out.println (”Item No.\tItem
Name\tEstimated\tDate Estimated ”);
System.out.println (”\t\t\t\t\tAnnual Ret\t Annual Ret
Updated”);
System.out.println
(”-----------------------------------------------------------
------------------\n”);

for (int counter = 0; counter <

NUM_RECORDS;counter++) {

if(portfolio[counter].number.compareTo(”00000000
0000”)!=0) {
System.out.print (portfolio[counter].number +
”\t\t”);
System.out.print (portfolio[counter].name +
”\t\t”);
System.out.print (portfolio[counter].ret +
”\t\t”);
System.out.print
(portfolio[counter].date.getMonth()+1)+”/”);
System.out.print
(portfolio[counter].date.getDate () + ”/”);
System.out.println
(portfolio[counter].date.getYear ());
}
}
System.out.println (”\n\n”);
System.out.println (” Press ENTER to return to
main menu”);
System.in.read (c);
}
catch(Exception e) {
}
} // investmentListing

//----------------------------------------------------------------------------
-----------------------------------
public void report (){
//
// rulează fiecare program de rapoarte
//
try {
byte choice[] = new byte[10];
boolean done = false;
StringBuffer input;

while (!done) {
clearScreen ();

System.out.println (“\n\n”);
System.out.println (“ MARTHA STOCKTON
GREENGAGE FOUNDATION ”);
System.out.println (“ REPORTS”);
System.out.println ();
System.out.println (“ 1.Listing of all
Investments”);
System.out.println ();
System.out.println (“ 2.Listing of all
Mortgages”);
System.out.println ();
System.out.println (“ 3.Results of weekly
computations”);
System.out.println ();
System.out.println (“ 4.Return to MAIN
MENU”);
System.out.println (”\n\n”);

System.out.println (“ Enter your choice and

press <ENTER>”);
System.in.read (choice);

switch ((char) choice [0]) {

case ’1’:
 investmentListing ();
break;
case ’2’:
clearScreen();
System.out.println (”\n\n”);
System.out.println (” LIST OF ALL
MORTGAGES\n”);
System.out.println (” This report is not
yet implemented in the prototype\n”);
System.out.println (”\n\n\n\n”);
System.out.println (” Press <ENTER> to
return to the menu”);
System.in.read (choice);
break;
case ’3’:
clearScreen ();
System.out.println (”\n\n”);
System.out.println(”WEEKLY
COMPUTATION REPORTS\n”);
System.out.println (” This report is not
yet implemented in the prototype\n”);
System.out.println (”\n\n\n\n”);
System.out.println (” Press <ENTER> to
return to the menu”);
System.in.read (choice);
break;
case ’4’:
case ’\n’:
done = true;
break;
default:
System.out.println (” Choice is out of
range \n”);
break;
} // switch
}
catch (Exception e){
 }
} // report

//----------------------------------------------------------------------------
-----------------------------------

public void mainMenu () {

try {
byte choice[] = new byte[10];
boolean done = false;

while (!done) {
clearScreen ();

System.out.println (“\n\n\n\n”);
System.out.println (“ MARTHA
STOCKTON GREENGAGE
FOUNDATION ”);
System.out.println (”\n\n”);
System.out.println ();
System.out.println (“ 1.Maintain Investment
data\n”);
System.out.println (“ 2.Maintain Operating
Expenses data\n”);
}

1.15.Tema practică
 Discuţie pe marginea exemplului de mai sus.
 Alegeţi un proiect soft. Parcurgeţi etapele prezentate în
lucrare, pornind de la colectarea cerinţelor până la
dezvoltarea unui prototip.