Resum

L’API del Java està formada per una gran jerarquia de classes que cobreixen una gran quantitat d’aspectes relacionats amb el desenvolupament de programari. Està organitzada en paquets (package) ordenats per temes. Els entorns de desenvolupament J2SE, J2EE i J2ME permeten la utilització de tots els paquets que subministren en el desenvolupament de programes Java, i l’entorn d’execució JRE permet l’execució de programes que utilitzen qualsevol de les classes de l’API. La documentació que proporciona l’entorn de desenvolupament corresponent conté un manual de referència complet, ordenat per paquets i classes, de tot el contingut de l’API, i la seva consulta resulta imprescindible en qualsevol desenvolupament.

L’API del Java s’organitza en subconjunts de classes agrupades per temàtiques/funcionalitats, els quals a vegades són batejats com a API (quan en realitat són un subconjunt de l’API del Java), o com a framework (entorn o marc de treball), o sense cap nom en concret.

Entre els diferents frameworks rellevants per començar a treballar en Java, es poden trobar els conjunts de classes vinculats a la gestió d’excepcions, les col·leccions destinades a emmagatzemar conjunts d’objectes, el tractament de fitxers estructurat usant XML o el processat de cadenes de text mitjançant expressions regulars.

La gestió d’excepcions és el conjunt de mecanismes que un llenguatge de programació proporciona per detectar i gestionar els errors que es puguin produir en temps d’execució. El llenguatge Java distingeix entre error i excepció, ja que el primers es corresponen a situacions irrecuperables, que no tenen solució i que no depenen del programador, el qual no s’ha de preocupar de capturar ni resoldre. No s’haurien de produir mai, però quan tenen lloc provoquen la finalització brusca del programa. En canvi, les excepcions corresponen a situacions excepcionals que els programes es poden trobar en temps d’execució, incloent-hi, fins i tot, els errors de programació. El programador pot preveure cada tipus d’excepció i escriure el codi adequat per a la seva gestió.

El llenguatge Java engloba tots els errors possibles en la classe Error i totes les excepcions possibles en la classe Exception. En aquesta classe cal distingir dos grans subtipus d’excepcions. Per una banda, les excepcions implícites que la mateixa màquina virtual s’encarrega de comprovar durant l’execució d’un programa i que el programador no té l’obligació ni de capturar ni de gestionar. Estan agrupades en la classe RuntimeException i normalment estan relacionades amb errors de programació. D’altra banda, les excepcions explícites (totes les de la classe Exception que no pertanyen a la subclasse RuntimeException), que el programador està obligat, allà on es puguin produir, a tenir-les en compte.

El llenguatge Java proporciona el mecanisme try – catch per capturar una excepció i definir l’actuació que correspongui, que consisteix a col·locar el codi susceptible de generar (llançar) l’excepció que es vol capturar dins un bloc de codi precedit per la paraula reservada try i seguit de tants blocs de codi catch com excepcions diferents es volen capturar, segons la sintaxi següent:

try {  
<bloc_de_codi_susceptible_de_llançar_excepció>  
} catch (nomClasseExcepció1 e1) {  
<bloc_de_codi_a_executar_si_en_el_bloc_try_s'ha_produït_una_nomClasseExcepció1>  
} catch (nomClasseExcepció2 e2) {  
<bloc_de_codi_a_executar_si_en_el_bloc_try_s'ha_produït_una_nomClasseExcepció2>  
} ... 
[finally {  
<bloc_de_codi_a_executar_en_qualsevol_cas–s'hagi_produït_o_no_una_excepció->  
}]

En produir-se un error/excepció dins el bloc try, la màquina virtual inicia un recorregut pels diferents blocs catch a la cerca del primer que cobreixi l’error produït i executa el codi que conté el bloc catch. Si no hi ha cap bloc catch que cobreixi l’error/excepció produït, la màquina virtual avorta el mètode llançant l’error/excepció al mètode que havia cridat el mètode actual. El bloc opcional finally s’executa sempre, s’hagi produït una excepció o no, i si s’ha produït, hagi estat capturada o no. Dins el bloc catch es té accés a l’objecte que la màquina virtual ha generat, corresponent a l’excepció produïda, i es disposa de mètodes per visualitzar la informació corresponent a l’error/excepció produïda.

El framework de col·leccions del Java és una arquitectura unificada per representar i gestionar col·leccions, independent dels detalls de la implementació. Està format per tres tipologies de components:

Interfícies. Tipus abstractes de dades (TAD) que defineixen la funcionalitat de les col·leccions i funcionalitats de suport. Dins d’aquestes, es poden trobar tant les que constitueixen el cor del framework i defineixen els diferents tipus de col·leccions (Set, List i Map), com classes de suport (Iterator i Comparable).
Implementacions. Classes que implementen les interfícies de les col·leccions, de manera que una interfície pot tenir més d’una implementació (classe que la implementi). En aquest sentit, existeixen classes que implementen les interfícies i que el programador pot utilitzar directament o declarant classes que en derivin, i classes abstractes que implementen les interfícies i que el programador pot utilitzar per derivar noves classes i sobreescriure únicament els mètodes que necessiti. Són classes pensades per facilitar la feina al programador i no veure’s obligat a implementar directament les interfícies i, per tant, sobreescriure tots els mètodes definits en aquestes.
Algorismes. Mètodes que realitzen càlculs (cerques, ordenacions…) en els objectes de les implementacions. La classe Arrays conté mètodes static destinats a gestionar (ordenar, omplir, realitzar cerques i comparar) les taules clàssiques del Java. També permet veure les taules clàssiques del Java com a objectes que implementen la interfície List.

Una altra problemàtica capaç de ser resolta de manera eficient mitjançant classes que ja existeixen a les llibreries del Java és la de poder generar i processar fitxers amb dades estructurades de manera autoexplicativa. Per fer-ho, s’usa el llenguatge XML, l’eXtensible Markup Language o llenguatge de marques extensible. Aquest permet definir un conjunt de paraules i símbols per descriure la identitat o la funció dels components d’un document (per exemple, “aquest és un paràgraf”, “aquesta és una llista”, “això és el títol d’aquesta figura”, etc.). Aquestes marques permeten facilitar el processat de les dades a tractar dins el fitxer. Per exemple, transformar el document en diferents formats de la sortida de pantalla, mitjançant un full d’estil. Mitjançant aquest llenguatge, les dades s’estructuren de manera jeràrquica a través de nodes, tal com mostra l’exemple següent de document XML:

<Producte id="1" aLaVenda="true">
  <Nom>Producte 1</Nom>
  <Preu>10.0</Preu>
  <Estoc>4</Estoc>
</Producte>

Java ofereix el package per convertir l’estructura del document XML en un conjunt d’objectes enllaçats entre si seguint exactament la mateixa jerarquia que en el document original, javax.xml.parsers. Aquesta aproximació al tractament de dades en XML és la que s’anomena model DOM (Document Object Model o model d’objectes de document). Les classes DocumentBuilderFactory i DocumentBuilder permeten obrir el fitxer i convertir-lo en els següents tipus d’objectes a memòria:

Document, que representa tot el document.
Element, els elements dins d’un document XML, caracteritzats per agrupacions lògiques de continguts etiquetades amb un nom. Al document, s’hi representen usant una parella de marques d’inici i de fi, amb format <NomElement>…</NomElement>. Un Element pot contenir-ne d’altres, generant l’estructura jeràrquica, o text, que el converteix en un node fulla.
Atribute, parelles de nom i valor, sempre associades a un element concret. S’escriuen dins la marca d’inici de l’element usant el format nom=“valor”. Si n’hi ha més d’un a l’element, se separen amb un espai en blanc.

Si es desitja escriure un document XML de memòria a fitxer, el procés és simplement l’invers. Primer es genera l’estructura d’objecte a la memòria, i un cop finalitzada, es pot desar al fitxer usant les classes TransformerFactory i Transformer.

Junt als frameworks anteriors, de certa complexitat, també n’hi ha de més simples però molt útils, com la capacitat de poder processar text per veure si aquest segueix un cert patró. Això es pot dur a terme mitjançant les expressions regulars, cadenes de text que defineixen aquests patrons i poden ser aplicades sobre text per establir si es compleix o no. Java proporciona el mètode matches de la classe String i la classe Pattern per poder aplicar patrons sobre textos arbitraris.

Finalment, una eina molt útil, tot i no ser estrictament part de cap framework Java, són els arrays multidimensionals. En aquests, per accedir a una posició concreta, en lloc d’usar un sol valor com a índex s’usa una seqüència de diversos valors. Cada índex serveix com a coordenada per a una dimensió diferent. Això permet definir taules N-dimensionals ordenades per diferents índexs. Tot i que el nombre d’índexs possibles no està fitat, normalment els més usats són els bidimensionals, que són equivalents a una taula amb files i columnes.

Per declarar-ne un d’inicialitzat amb totes les posicions dels seus valors per defecte i posteriorment accedir-hi, caldria usar la sintaxi:

//Declaració
paraulaClauTipus[] identificadorVariable = new paraulaClauTipus[nombreFiles][nombreColumnes];

//Accés
identificadorVariable[índexFila][índexColumna]