Java amb BlueJ: mòdul 2, pràctica 3.

Mòdul 2

Pràctica 3: Camps, Paràmetres i Variables Locals. Els diferents tipus de mètodes.

En aquesta pràctica estudiaràs els tres tipus de variables amb que treballen les classes de Java: els camps, que ja coneixes, els paràmetres i les variables locals. Seguiràs aprofundint, també, en la classificació dels mètodes de Java en funció del tipus de feina que fan.

Passar dades als mètodes a través de paràmetres

La forma en què els mètodes recullen informació de l'exterior és a través del seus paràmetres. Els has estat utilitzant des del primer mòdul i també a la classe Mobil. Observa aquest mètode:

public void carrega(int quantitat) {
saldo+=quantitat;
}

Serveix per a carregar la targeta, és a dir, afegir una certa quantitat al saldo de què disposem. Aquest és un mètode void, que, tal com està no ens retornarà el nou valor del camp saldo, només farà alguna feina. La feina que ara com ara tenim en el codi que hem mostrat és incrementar el saldo i el mètode ho fa utilitzant una sentència d'assignació amb l'operador +=.

Com podem fer per demanar-li al mètode la quantitat en que s'ha d'incrementar el saldo? Establim aquesta comunicació amb el mètode mitjançant un paràmetre.

En aquest exemple el paràmetre es diu quantitat. El posem entre parèntesis immediatament desprès del nom del mètode a la seva capçalera. Observa que hem d'especificar el tipus de dada que conté el paràmetre. Nosaltres passem un enter (int quantitat).

Si has de passar més d'un paràmetre als teus mètodes, els has d'anar posant un darrere l'altre i separant-los amb comes. Per exemple, imagina que la companyia telefònica ofereix una bonificació a tots els usuaris que carreguin la seva targeta a les oficines de la companyia. Podríes escriure un nou mètode de càrrega que ho reflectís:

public void carregaAmbBonificacio( int quantitat, int bonificacio ) {
saldo+=(quantitat+bonificacio);
}

Si tens curiositat per dominar correctament la terminologia del llenguatge has de saber que el paràmetre que escrivim a la capçalera dels mètodes té el nom de paràmetre formal. El valor que li donem, el que té quan entra al cos del mètode és el paràmetre actual. Li diem així perquè, un cop dins del mètode, el valor del paràmetre pot anar canviant.

Visibilitat i cicle de vida de les variables. Variables locals

Al mètode anterior li hem passat dos paràmetres. Quan introduïm aquesta informació al mètode, la màquina de Java la pren i en col·loca el seu valor a la memòria RAM de l'ordinador. També considerem el valor dels camps o variables d'instància. Sovint haurem de crear variables auxiliars que ens ajudin en la feina que fan els mètodes. Ara és hora de fer-se dues importants preguntes que has de saber contestar perfectament bé si t'interessa fer poques errades de programació:

Des d'on es veu una variable? Fixa't que una variable es pot veure (és a dir que el programa reconeix la variable i el valor actual que té) des de l'exterior de la classe, des de qualsevol lloc a l'interior de la classe, exclusivament des de dins d'un mètode o, fins i tot, exclusivament dins d'un fragment de mètode. Tot depèn del lloc on estigui creada la variable.
Fins quan es veu una variable? En quin moment la màquina de Java esborra la variable de la memòria i ja no la pots usar més?

Aquests aspectes constitueixen la visibilitat i el cicle de vida de les variables. És un tema central de la programació que Java resol d'una manera senzilla, seguint les regles següents:

Una variable només es veu a l'interior del cos del mètode, constructor o fragment de codi que l'ha creat . El paràmetre quantitat es crea dins del mètode carrega. Això significa que aquest enter només és visible a dins d'aquest mètode, no es pot utilitzar a cap altre lloc de l'objecte.
Per extensió, qualsevol variable creada dins d'un parell del claus { } només és visible a l'interior d'aquestes claus. Així de fàcil i estricte.

El cicle de vida d'una variable és el mateix que el del cos en què ha estat creada. En l'exemple del mètode carrega la màquina de Java fa desaparéixer la variable un cop ha estat feta la recàrrega.

Per a demostrar aquestes característiques, pots jugar una estona a fer saltar el programa. Ara et proposem unes modificacions a la classe Mobil que incompleixen els principis de visibilitat de Java. A veure si dedueixes per què es produeixen.

Primera Situació: Utilitzar variables fóra del cos del mètode que les ha creades:

Obre amb el el projecte que conté la classe Mobil, edita'n el codi i intenta utilitzar el paràmetre quantitat a l'interior del constructor.

public Mobil() {
    saldo = 350;
    preu = 2;
    quantitat = 5;
}

Has d'obtenir un error en temps de compilació que t'avisarà amb una frase de l'estil cannot resolve symbol - variable quantitat. El que succeeix és que l'enter quantitat era un paràmetre del mètode carrega i només és visible al seu interior. Com que el que hem fet és un exemple d'errada, convé que esborris la línia que provoca aquesta anomalia ( i el mateix en els altres exemples que et proposem en aquesta part de la pràctica.)

Segona Situació: Utilitzar variables fora de les claus { } on han estat creades. Modifica el mètode carrega de la següent forma:

public void carrega(int quantitat) {
    saldo+=quantitat;
    {
        int numeroCarregues = 1;
    }
    numeroCarregues+=1;
}

Observa que hem posat claus d'una forma arbitrària.

En situacions reals de programació les claus s'utilitzen, a més de fer-ho en la definició del cos dels mètodes, com ja saps, en sentències de control de flux que començaràs a aprendre a la pràctica següent. Si intentes compilar la classe amb aquest mètode tornaràs a rebre el mateix avís d'error del compilador: has intentar utilitzar la variable numeroCarregues fora del fragment de codi delimitat per {} on l'has creat.

Observa la variable numeroCarregues i observa també aquesta modificació del mètode carrega amb la creació d'una nova variable, la variable lògica (boolean) isClientEstrella.:

public void carrega(int quantitat) {
    saldo+=quantitat;
    /*
     * Creem una variable lògica. En crear-se, el programa
     * verifica si el saldo>=50000 i n'assigna a la variable
     * el valor de la comprovació.
     */
    boolean isClientEstrella=(saldo>=50000);
    if (isClientEstrella) {
        System.out.println("Vosté és client estrella");
    } else {
        System.out.println
          ("Vosté no és encara client estrella");
    }
}

Modifica el codi, recompila i carrega el mòbil vàries vegades, fins a passar de 50000 unitats de saldo. Observa com varia la resposta del programa. A la pràctica següent estudiaràs el detall d'aquesta acció.

El que ara ens interessa és que et concentris en les humils variables numeroCarregues i isClientEstrella. Aquest tipus de variables són conegudes com a variables locals.

Les variables locals es creen a l'interior d'un mètode i serveixen exclusivament durant la vida d'aquell mètode. Executat el mètode, moren a la memòria de l'ordinador.

Les variables locals són una mica com els peons d'una partida d'escacs, modestos però eficients. Tenen una peculiaritat quant a la seva inicialització respecte els camps: recordes que els camps s'inicialitzen per defecte només declarar-los? Les variables locals no.

Les variables locals s'han d'inicialitzar amb algun valor abans d'utilitzar-les. Si no ho fas, rebràs un error de compilació.

Pensa ara en la variable isClientEstrella. L'hem creat com a variable local. Coneixent el què has après sobre visibilitat de variables, quin lloc creus que seria més adient per a una informació d'aquest tipus, en una variable local o en un camp? Perquè?

Modifica la classe Mobil i incorpora la variable isClientEstrella a la llista de camps i suprimeix la línia que la defineix del mètode carrega.

Ara estàs ja en condicions d'identificar els tres tipus de variables que s'utilitzen a les classes de java: els camps, els paràmetres i les variables locals. Resumim una mica la seva visibilitat i cicle de vida:

Els camps es creen fora dels constructors i els mètodes i són visibles des de qualsevol lloc de la classe. Si un camp no el declarem com a private, també és visible fóra de la classe. Si el declarem private, només es veu dins de la classe.
Els camps persisteixen al llarg de la vida de l'objecte, no moren fins que no mori el propi objecte.
Els paràmetres i variables locals només es veuen dins del mètode o fragment de codi que els ha creat i només viuen el temps d'existència del mètode que els ha cridat.
Els paràmetres es declaren a la capçalera dels mètodes i constructors, obtenen les dades de l'exterior, però només són visibles a l'interior del mètode o constructor.
Les variables locals s'han d'inicialitzar amb algun valor forçosament abans d'utilitzar-les, a diferència dels camps que reben valors per defecte.

Diferents tipus de mètodes

La classe Mobil disposa d'alguns dels tipus de mètodes més estesos en la programació Java:

Mètodes d'accés a dades.
Mètodes transformadors de dades.
Mètodes de sortida.

És important que siguis conscient de quin tipus de mètode estàs fent quan programes perquè això farà que el codi que escrius tingui una bona qualitat. Observem amb una mica de detall les característiques de cadascun dels tipus.

Mètodes d'accés a dades

La nostra classe disposa d'un grup de mètodes d'aquest tipus:

/**
* Retorna el saldo restant a la targeta
*/
public int getSaldo() {
return saldo;
}

La seva feina és molt simple: retornen el valor o estat de camps que, al declarar-los privats, no són visibles des de l'exterior de l'objecte. Per extensió, qualsevol mètode que retorni informació sobre l'estat d'un objecte el classifiquem com a mètode d'accés.

Observa com en tots els casos (saldo, preu, número, etc) hem adoptat una forma uniforme de batejar els mètodes accessors:

get + el nom del camp privat al que volem accedir.

Pensa que no està fet per caprici: és una altra de les convencions del llenguatge que has d'utilitzar invariablement i que serveix a qualsevol lector humà del codi per a interpretar que estem fent un accés a un camp o una petició de dades. I no només els lectors humans; si et dediques a la programació professional amb Java descobriràs que algunes tecnologies obliguen els programadors a utilitzar aquesta sintaxi.

Com pots suposar, els mètodes d'accés porten invariablement un return com a final de la seva tasca.
També convé que recordis que a la pràctica anterior ja ens hem fixat en la capçalera d'aquests mètodes i hem vist que hi apareix un tipus de dada.

Mètodes de transformació de dades

Qualsevol mètode que canvia l'estat de l'objecte és un mètode transformador.

Aquest n'és un exemple:

/**
* Fa una trucada del número de passos que triem. Decrementa
* el nostre saldo en funció del preu de cada pas
*/
public void truca(int passos) {
saldo-=(passos*preu);
}

Observa que el mètode rep un paràmetre i canvia l'estat de l'objecte: en modifica el saldo mitjnçant un operador -=. Com que la capçalera o signatura del mètode és void, no retorna res.

En general, els mètodes transformadors no necessiten tornar res, aquesta és una feina que hem d'intentar deixar als mètodes d'accés.

Mètodes de sortida

Es tracta de mètodes que tenen com a funció la sortida de dades cap a diferents tipus de dispositius. Com aquest exemple:

/**
* Imprimeix el nostre saldo. Per la feina de la consulta, ens
* resta una unitat
*/
public void printSaldo() {
    saldo-=1;
    System.out.println("El vostre saldo és de "+saldo);
    System.out.println("moltes gràcies per la consulta");
}

Observa que es tracta de mètodes de tipus void; la sortida es fa a l'interior del mètode, però el mètode, en sí mateix, no retorna el valor de cap variable.

En aquest exemple, la sortida es fa a la consola de text, però amb Java podríem fer sortides cap a altres dispositius, des de fitxers a pàgines web.

La sentència System.out.println(...) és la utilitzada per a connectar amb la consola de text. Cada cop que la cridem, genera una línia de text a la consola amb la cadena que li passem com a paràmetre. Si no li passem cap cadena, genera una línia en blanc.
Si en lloc d'escriure una línia per sentència volem anar escrivint totes les sortides a la mateixa línia, podem utilitzar la sentència System.out.print(...).

Modifica el mètode printSaldo() canviant-hi els System.out.println() per System.out.print(); adequa una mica la segona sentència de manera que quedi com es veu tot seguit i observa les diferències de sortida amb l'original.

/**
* Imprimeix el nostre saldo. Per la feina de la consulta, ens
* resta una unitat
*/
public void printSaldo() {
    saldo-=1;
    System.out.print("El vostre saldo és de "+saldo);
    System.out.print(". Moltes gràcies per la consulta");
}

Diuen els experts que quant menys barregem les funcionalitats dels mètodes, més qualitat tindran els nostres programes. Moltes vegades estaràs tentat de fer mètodes d'accés que també fan modificacions sobre l'estat de l'objecte. No està prohibit i alguns cops és inevitable, però és millor intentar separar les tasques en mètodes diferents: si pots, construeix mètodes void transformadors per a fer