Instruccions

Totes les instruccions en Java acaben en punt i coma (;).

Instrucció de declaració de variables

Tipus variable ;

o també

Tipus variable_1, variable_2, ... variable_n;

on Tipus és un tipus (int, double, ...) i nom_variable és el nom d’una variable.

Per exemple, per declarar una variable de tipus enter, de nom x tindrem:

int x;

Per a declarar dues variables de tipus real de nom numedaros i denominador, tindrem:

double numerador, denominador;

Instruccions d’assignació

Per exemple, per a assignar el producte de 10 i 3 a la variable x farem:

x = 10 * 3;

i prèviament haurem declarat x de tipus enter de la següent manera:

int x;

Per exemple, per a assignar a la variable mitjana, la mitjana aritmètica dels valors de tres variables de tipus enter x, y i z, tindrem:

mitjana = (x + y + z) / 3;

i prèviament, haurem declarat

int mitjana, x , y, z;

Per a assignar a la variable son_iguals de tipus booleà si dues altres variables de tipus enter són iguals, farem:

int x , y;

booelan son_iguals;

.

. (altres instruccions)

.

son_iguals = (x == y);

son_iguals tindrà el valor True (cert) si x i y són iguals; és a dir, si avaluen (tenen) el mateix valor, o fals altrament.

Important: Per a assignar un valor a una variable, prèviament haurem hagut de declarar aquesta variable.

Important: La variable i el valor que li assignem, hauran de ser del mateix tipus.

Important: una variable només es pot declarar una sola vegada.

Altres instruccions d'assignació

Tenim altres maneres d'assignar un valor a una variable. Amb els operadors matemàtics, per exemple, tenim:

• variable ++, que serveix per a augmentar en una unitat una variable.

int v = 0; v++;

és equivalent a:

int v = 0; v = v + 1;

• variable += expressió, que serveix per incrementar la variable el valor de l'expressió.

 

int v = 0; int a = 10; v += (10 + a);

és equivalent a:

int v = 0; int a = 10; v = v + (10 + a);

 

• Similarment, variable -= expressió serveix per decrementar la variable en el valor de l'expressió.

 

int v = 0; int a = 10; v -= (10 + a);

és equivalent a:

int v = 0; int a = 10; v = v - (10 + a);

Podem construir també --, *=, /=, etc.

Instrucció de declaració de tipus i assignació

Podem declarar una variable i assignar-li un valor alhora amb una sola instrucció:

Tipus nom_variable = valor;

on Tipus és un tipus (int, double, etc.), i nom_variable és el nom d’una variable.

Aquesta instrucció és equivalent a les instruccions:

Tipus nom_variable;

nom_variable = valor;

Instrucció alternativa

També tenim:

Una altra opció per a simular una instrucció alternativa, és amb la següent instrucció en Java:

switch(variable)

{

case CONST1:

{I1; break;}

case CONST2:

{I2; break;}

.

.

.

case CONSTn:

{In; break;}

default:

{In+1}

}

Aquesta instrucció funciona de la següent manera: si la variable és igual a la constant CONST1, aleshores executa les instruccions I1, altrament si és igual a la constant CONST2, aleshores executa les instruccions I2, ... altrament si és igual a la constant CONSTn, aleshores executa les instruccions In, i finalment, si no és igual a cap de les constants, executa les instruccions In+1.

És, per tant, equivalent al següent codi en Java:

if (variable == CONST1)

{I1}

else if (variable == CONST2)

{I2}

else if (variable == CONST3)

{I3}

.

.

.

else if (variable == CONSTn)

{In}

else

{In+1}

Important: per a que la instrucció switch funcioni, cal que la variable i les constants siguin del mateix tipus (obvi) i que a més, aquests tipus siguin comparables amb l’operador ==. Tots els tipus simples ho són. En canvi, el tipus String no ho és. Per tant, no podriem utilitzar la instrucció switch amb una variable de tipus String.

Instrucció d’iteració

Tenim les següents instruccions:

En la instrucció for, tant inici com final són de tipus int. De tota manera, aquesta instrucció és molt flexible que no pas la instrucció per a en pseudocodi. El que hi ha entre parèntesi després del for és de la següent manera:

for (inicialització ; condició d’acabament ; increment)

{ I }

on inicialització és una instrucció, normalment una assignació, condició d’acabament és una expressió booleana que quan es fa falsa acaba la instrucció, i increment és una altra instrucció, normalment un decrement de la fita. De fet, la instrucció for és equivalent a la següent llista d’instruccions amb while:

inicialització;

while( condició d’acabament)

{ I ; increment; }

És a dir, la instrucció for en Java és més flexible i genèrica que la instrucció per en pseudocodi.

Accions i funcions

Les funcions, les declarem així:

on declaració de paràmetres és una llista com aquesta:

Tipus variable, Tipus variable, ..., Tipus variable

Les accions les declarem d’aquesta manera:

on declaració de paràmetres és igual com a les funcions.

Comentari sobre els paràmetres en Java:

En pseudocodi, indiquem si els paràmetres són d’entrada, d’entrada i sortida, o de sortida. Dir que un paràmetre és d’entrada, és equivalent a dir que el paràmetre es passa per valor. Dir que el paràmetre és de sortida, o d’entrada i sortida, és equivalent a dir que el paràmetre es passa per referència. En Java les coses són de la següent manera:

• Els paràmetres de tipus simples (int, double, char, boolean) es passen sempre per valor.
• Els tipus compostos (vectors, matrius i String) es passen sempre per referència. Les preguntes que ens podem fer són:

Ja que el Java no ens ofereix mecanismes directes per a fer el pas de paràmetres per valor o per referència, podem fer-nos aquestes preguntes:

Pregunta: Com podem passar un paràmetre de tipus simple per referència?

Resposta: Passant un vector del mateix tipus, amb un sol valor. Per exemple, si volem passar un paràmetre de tipus int com a entrada/sortida, en comptes de passar una variable i de tipus int, passaríem un vector de tipus int [] (diguem que el nom d’aquest vector és v) amb un sol element a v[0] que seria justament i. Un cop haurem tornat de la crida, caldrà actualitzar i amb el valor de v[0].

Pregunta: Com podem passar un paràmetre de tipus compost per valor?

Resposta: Simplement, cal evitar, en el cos de l’acció, posar aquest paràmetre a l’esquerra d’una assignació. És a dir, hem de ser nosaltres els que hem d’evitar que aquest paràmetre "actuï" com si fos un paràmetre passat per referència.