Resum

El desenvolupament d’una aplicació informàtica es pot dividir en un conjunt de fases que prenen com a punt de partida la detecció de la necessitat de fer un programa, i que finalitzen quan es comprova que aquest ja funciona correctament. Ara bé, sovint es detecta més endavant que hi ha errades que cal reparar o noves funcionalitats que estaria bé incloure. En aquest cas, com que l’aplicació informàtica es troba en contínua evolució, s’acostuma a parlar del seu cicle de vida.

La primera etapa és la definició del problema, en la qual s’exposa de manera clara què ha de fer el programa i amb quins recursos, encara sense preocupar-se de com. En aquesta etapa és molt important dur a terme una anàlisi funcional, a partir de la qual es genera una llista de les tasques que ha de ser capaç de resoldre el programa. En aquesta etapa encara no es genera codi font.

Un cop es té clar el problema per resoldre, és el moment d’atacar com fer-ho, pensant una estratègia. Aquesta etapa és la que es coneix com a disseny de l’algorisme. Un algorisme no és més que una descripció de com resoldre un problema en forma de seqüència ordenada i finita de passes. En aquest cas, cada passa serà una instrucció que el programa ha de donar a l’ordinador. Si bé tots els programes es basen en algorismes, aquest terme és aplicable a qualsevol procés que compleixi aquestes condicions. Per exemple, una recepta de cuina o les instruccions per muntar un moble.

Hi ha diferents aproximacions per plantejar un algorisme, però la més acceptada per generar aplicacions informàtiques és la programació estructurada. Aquesta es basa en el fet que tot conjunt d’instruccions només es pot organitzar d’acord amb tres tipus d’estructura possibles:

Estructura lineal, en què les instruccions s’executen en el mateix ordre en què s’han escrit.
Estructura de selecció o condicional, en què hi ha certes condicions que provoquen l’execució de blocs d’instruccions diferents depenent de si es compleixen o no aquestes condicions.
Estructura de repetició o iterativa, en què el bloc d’instruccions s’executa un nombre finit de vegades, ja sigui un nombre concret o fins que es compleix una condició.

Cadascuna d’aquestes estructures estableix el flux de control del programa resultant, o sigui, l’ordre en què es van seguint les instruccions. L’algorisme resultant estarà determinat per la combinació de blocs d’instruccions dins d’estructures de qualsevol tipus.

Normalment, només els algorismes extremadament simples usen estructures lineals només. Les estructures de selecció i repetició són molt importants. En tots dos casos, aquestes estructuren un bloc d’instruccions i prenen decisions sobre què cal fer-hi d’acord amb l’avaluació d’una expressió que ha de donar un resultat booleà: true (cert) o false (fals). Aquesta expressió s’anomena la condició lògica de l’estructura.

Per al cas de les estructures de selecció, s’estableixen diferents blocs d’instruccions de manera ordenada, de manera que a cadascun se li assigna una condició lògica. Cada bloc es correspon amb una branca en el flux de control. Quan l’algorisme arriba a una estructura d’aquest tipus, va avaluant ordenadament les diferents condicions lògiques de cada branca. Només s’executaran les instruccions de la primera branca en què la condició lògica avaluï a cert. La resta de branques s’ignoren totalment, com si les seves instruccions no existissin dins el codi font.

Hi ha diferents possibilitats de crear branques amb diferents blocs d’instruccions:

La selecció simple permet controlar el fet que s’executi un únic bloc d’instruccions si i només si es compleix la condició lògica (és a dir, el resultat d’avaluar la condició lògica és igual a true). En cas contrari, no s’executen. En Java s’implementa amb la sentència if.
L’estructura de selecció doble permet controlar el fet que s’executi un bloc d’instruccions, només si es compleix la condició lògica, i que se n’executi un altre, només si no es compleix la condició lògica. En Java s’implementa amb la sentència if/else.
La selecció múltiple permet controlar el fet que en complir-se un cas entre un conjunt finit de casos s’executi el conjunt d’instruccions corresponent. En Java s’implementa amb la sentència if/else if/else.

Per al cas de les estructures de repetició, mentre la condició lògica avaluï a cert, les instruccions del bloc s’aniran repetint en el mateix ordre com apareixen indefinidament. Cada cop que s’han executat totes es torna a avaluar la condició. Si encara és certa, es torna a començar, i si és falsa, es deixen de repetir. Anomenem bucle o cicle el conjunt d’instruccions que s’ha de repetir un cert nombre de vegades, i anomenem iteració cada execució individual del bucle.

En la majoria de casos, la condició lògica es basa en el valor d’una variable, anomenada variable de control. Aquesta sol complir un dels tres papers següents:

Comptador: una variable de tipus enter que va augmentant o disminuint, indicant de manera clara el nombre d’iteracions que caldrà fer.
Acumulador: una variable en què es van acumulant directament els càlculs que es volen fer, de manera que en assolir cert valor es considera que ja no cal fer més iteracions. Si bé s’assemblen als comptadors, no són ben bé el mateix.
Semàfor: una variable que serveix com a interruptor explícit de si cal continuar fent iteracions. Quan ja no en volem fer més, el codi simplement s’encarrega d’assignar-li el valor específic que servirà perquè la condició avaluï false.

El llenguatge Java ofereix diferents tipus de sentència per implementar estructures de repetició. Les més habituals són while i for. En el primer cas, permet repetir l’execució del bucle mentre es verifiqui la condició lògica. Aquesta condició es verifica al principi de cada iteració. Si la primera vegada, tot just quan s’executa la sentència per primer cop, ja no es compleix, no s’executa cap iteració. En el segon cas, la sentència permet repetir un nombre determinat de vegades un conjunt d’instruccions, ja que es basa en un comptador que s’incrementa automàticament al final de cada iteració.

Un cop s’ha dissenyat l’algorisme es pot procedir a implementar el programa, escrivint el codi font. Per això, caldrà traduir cadascuna de les passes de l’algorisme a instruccions o sentències acceptades pel llenguatge de programació escollit. El text del fitxer de codi font haurà de seguir totes les normes de sintaxi del llenguatge, o en cas contrari hi haurà errors de compilació.

Finalment, quan el programa ja s’ha implementat i compila, és el moment de dur a terme verificacions i proves, per veure que fa les tasques encomanades correctament. En aquesta fase cal ser especialment acurat comprovant tots els casos conflictius. Només un cop s’està molt segur que tot funciona perfectament, és el moment de la posada en marxa i l’explotació en un entorn real.