M3 - Programació estructurada / Continguts UF1: Estructura alternativa

Estructures de selecció

Les estructures de selecció permeten prendre decisions sobre quin conjunt d’instruccions cal executar en un punt del programa.

Tota estructura de selecció es basa en 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.

El conjunt d’instruccions que s’executarà dependrà del resultat de la condició lògica, i actuarà com una mena d’interruptor que marca el flux que cal seguir dins del programa.

Una desviació temporal del camí: selecció simple

L’estructura de selecció simple permet controlar el fet que s’executi un conjunt 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.

Un exemple seria el programa d’una botiga virtual que aplica un descompte al preu final d’acord amb un cert criteri (per exemple, si la compra total és com a mínim de 100 €). En aquest cas, hi ha un conjunt d’instruccions, les que apliquen el descompte, que només s’executen quan es compleix la condició. En cas contrari, s’ignoren i el preu final és el mateix que l’original.

Sintaxi i comportament

Per dur a terme aquest tipus de control sobre les instruccions del programa, cal usar una sentència if (si...). En el cas del Java, la sintaxi és la següent:

  instruccions del programa
  if (expressió booleana) {
        Instruccions per executar si l’expressió avalua a true (cert)
  }
  resta d’instruccions del programa

Si entre els parèntesis es posa una expressió que no avalua un resultat de tipus booleà, hi haurà un error de compilació.

Exemple: calcular un descompte

Es vol fer un programa que apliqui un descompte a un preu depenent del seu valor. Per veure clarament que hi ha diferents camins dins de les instruccions, primer de tot establirem quines són les tasques que ha de fer el programa i en quin ordre.

El programa hauria de fer:

1. Decidir quin és el valor mínim per optar al descompte i quant es descomptarà.
2. Demanar que s’introdueixi el preu inicial, en euros, pel teclat.
3. Llegir-lo.
4. Veure si el preu introduït és igual o major que el valor mínim per optar al descompte.
(a) Si és així, s’aplica el descompte sobre el preu inicial.
5. Mostrar el preu final.

En el pas 4 es pot observar que cal prendre una decisió d’acord amb una condició i que alguna de les tasques només es fa si aquesta es compleix (el pas 1). Per tant, queda establert que cal una estructura de selecció simple. Partint d’aquí, un possible codi font que correspondria a aquest esquema seria el següent. Observeu quines instruccions es corresponen a cadascuna de les passes escrites.

Tot seguit es mostra el codi font que du a terme aquestes tasques. Compileu-lo, executeu-lo i observeu com el resultat final mostrat per pantalla és diferent segons el valor que introduïu pel teclat.

import java.util.Scanner;

//Un programa que calcula descomptes.

public class Descompte {

  public static void main(String[] args) {
    //Es fa un descompte del 8%.
    final double DESCOMPTE = 0.08;
    //Es fa descompte per compres d’un mínim de 100 euros.
    final float COMPRA_MIN = 100;
    Scanner lector = new Scanner(System.in);
    double preu, descompteFet;
    System.out.print("Quin és el preu del producte, en euros? ");
    preu = lector.nextFloat();
    lector.nextLine();
    if (preu >= COMPRA_MIN) {
       descompteFet = preu * DESCOMPTE;
       preu = preu - descompteFet;
    }
    System.out.println("El preu final per pagar és de " + preu + " euros.");
  }
}

Aspectes importants de la selecció simple

• L’expressió booleana que denota la condició lògica pot ser tan complexa com es vulgui, però ha d’estar sempre entre parèntesis.
• Les instruccions que cal executar si la condició és certa estan englobades entre dues claus ({, }). Aquest conjunt es considera un bloc d’instruccions associat a la sentència if (bloc if ).
• La línia on hi ha les claus o la condició no acaba mai en punt i coma (;), al contrari que altres instruccions.
• Tot i que no és imprescindible, és un bon costum que les instruccions del bloc estiguin sagnades.

Amb la introducció d’estructures de selecció simple també apareix per primer cop codi font amb diferents blocs d’instruccions: el del mètode principal i els associats a la sentència if. La principal característica d’aquest fet és que la relació entre blocs és jeràrquica: tots els nous blocs d’instruccions són subblocs del mètode principal.

A mode de resum, la taula següent mostra una petita llista d’errors típics que es poden cometre en usar una sentència if.

Missatge d'error en compilar	Error comès	Exemple
'(' expected	Expressió no envoltada de parèntesis	if preu>=COMPRA_MIN){
';'expected	Falta ; en alguna instrucció del bloc if	preu = preu - descompteFet
Sempre executa bloc if	S'ha posat ; a la sentència if	if (preu>=COMPRA_MIN); {
Només fa condicionalment la primera instrucció del bloc if, la resta la fa sempre	Falten les claus que han d'envoltar el bloc, {...}	if (preu>=COMPRA_MIN)

• Quan el bloc if només té una única instrucció, l’ús de claus és opcional. De totes maneres, és molt recomanable usar-les sempre, independentment d’aquest fet. Això facilita la identificació del bloc de codi associat a la sentència if quan s’està llegint el codi font.

Dos camins alternatius: la sentència ”if/else”

Suposeu que ara voleu fer un programa en què s’ha d’intentar endevinar un nombre entre 1 i 10. En aquest cas, i a diferència de l’anterior, ara hi ha dos escenaris excloents: o s’ha endevinat el nombre, o no s’ha endevinat. Segons de quin cas es tracti, la resposta del programa ha de ser diferent. Per tant, a més a més de codi comú per a qualsevol cas i d’un bloc que especifiqui les accions per dur a terme si es compleix la condició, ara en cal un altre que indiqui què cal fer només en cas contrari. Per poder fer això tenim l’estructura de selecció doble, la sentència if/else (si... si no...).

L’estructura de selecció doble permet controlar el fet que s’executi un conjunt 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.

És important recordar que els dos blocs de codi són excloents. Mai no pot passar que tots dos s’acabin executant.

Sintaxi i comportament

Per dur a terme aquest tipus de control sobre les instruccions del programa, cal usar una sentència if/else (si... si no...). En el llenguatge Java, la sintaxi és la següent:

  if (expressió booleana) {
     Instruccions per executar si l’expressió l’avalua a true - Bloc if
  } else {
     Instruccions alternatives per executar si l’expressió l’avalua a false - Bloc else
  }

El bloc if té exactament les mateixes característiques que quan s’usa en una estructura de selecció simple. Aquestes es compleixen també per al cas del bloc else, amb la particularitat que no té cap expressió assignada. Simplement, quan la condició lògica de la sentència if no es compleix s’executen les instruccions del bloc else.

Si per algun motiu no es posa cap instrucció dins del bloc else i es deixa un espai buit entre les dues claus, la selecció doble es comporta igual que la selecció simple. En aquest cas, és millor usar només la sentència if en lloc de if/else.

Exemple: endevina el nombre secret

Un possible codi d’un programa en què s’intenta endevinar un nombre serveix per mostrar amb més claredat com es pot usar una sentència if/else. Novament, abans de veure’l val la pena reflexionar sobre quines són les tasques que hauria de fer el programa i en quin ordre.

Bàsicament, el programa ha de fer:

1. Decidir quin serà el nombre per endevinar.
2. Demanar que s’introdueixi un nombre pel teclat.
3. Llegir-lo.
4. Veure si el nombre introduït és igual al valor secret:
     (a) Si és igual que el nombre pensat, informa que s’ha encertat.
     (b) Si no, informa que s’ha fallat.

Queda clar que en el pas 4 cal prendre una decisió d’acord amb una condició.

El programa haurà d’emprendre dues vies d’acció diferents segons si la condició es compleix o no. Per tant, cal una estructura de selecció doble. Partint d’aquí, un possible codi font que correspondria a aquest esquema seria el següent. De nou, observeu quines instruccions es corresponen a cadascun dels passos descrits. Compileu-lo i executeu-lo per veure com funciona.

import java.util.Scanner;
//Un programa en què cal endevinar un nombre.
public class Endevina {

  public static void main(String[] args) {
  //El nombre per endevinar serà el 4.
     final int VALOR_SECRET = 4;
     Scanner lector = new Scanner(System.in);
     System.out.print("Endevina el valor enter, entre 0 i 10: ");
     int valorUsuari = lector.nextInt();
     lector.nextLine();
        //Estructura de selecció doble. O s’endevina o es falla.
     if (VALOR_SECRET == valorUsuari) {
        System.out.println("Exacte! Era " + VALOR_SECRET + ".");
     } else {
        System.out.println("T’has equivocat!");
     }
     System.out.println("Hem acabat el joc.");
  }
}

Diversos camins: la sentència ”if/else if/else”

Finalment, a l’hora d’establir el flux de control d’un programa, també hi ha la possibilitat que hi hagi un nombre arbitrari de camins alternatius, no solament dos. Per exemple, imagineu un programa que, a partir de la nota numèrica d’un examen, ha d’establir quina és la qualificació de l’alumne. Per això caldrà veure dins de quin rang es troba el nombre. En qualsevol cas, els resultats possibles són més de dos.

L’estructura de 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.

Sintaxi i comportament

Aquest tipus de control sobre les instruccions del programa té associada la sentència if/else if/else (si és el cas, en aquest altre cas, si no és cap cas). Bàsicament, es tracta de la mateixa estructura que la sentència if/else, però amb un nombre arbitrari de blocs if (després del primer bloc, anomenats else if).

La figura següent mostra un esquema del flux d’execució, d’acord amb el resultat d’anar avaluant cadascuna de les condicions lògiques. En aquest cas és una mica més complicat, ja que, com es pot veure, hi ha més d’una condició lògica dins de la sentència. Cada condició es va avaluant ordenadament, des de la primera fins a la darrera, i s’executarà el codi del primer cas en què l’expressió avaluï com a cert. Un cop fet això, ja no es torna a avaluar cap altra condició restant i s’ignora la resta de blocs. Si en aquest procés es dóna el cas que cap de les expressions avalua a cert, s’executaran les instruccions del bloc else.

El punt important d’aquesta sentència és que només s’executarà un únic bloc de tots els possibles. Fins i tot en el cas que més d’una de les expressions booleanes pugui avaluar a cert, només s’executarà el bloc associat a la primera d’aquestes expressions dins de l’ordre establert en la sentència.

També és destacable el fet que el bloc else és opcional. Si no volem, no cal posar-lo. En aquest cas, si no es compleix cap de les condicions, no s’executa cap instrucció entre les incloses dins de la sentència.

Exemple: transformar avaluació numèrica a text

La manera d’usar la sentència if/else if/else es pot veure millor mitjançant el codi de l’exemple proposat anteriorment. Un cop més, abans de veure el codi es repassaran els passos que ha de fer el programa per dur a terme el seu objectiu i l’ordre que cal seguir.

1. Demanar que s’introdueixi la nota pel teclat.
2. Llegir-la.
3. Mostrar un text o un altre segons el rang de valors dins del qual es troba la nota:
     (a) Si és major o igual que 9 i menor o igual que 10, la nota és “Excel·lent”.
     (b) Si és major i igual que 6,5 però estrictament menor que 9, la nota és “Notable”.
     (c) Si és major i igual que 5 però estrictament menor que 6,5, la nota és “Suficient”.
     (d) Si no és cap dels casos anteriors, la nota és de “Suspès”.

Aquest cop és el pas 3 el que presenta diferents possibilitats segons si es compleixen certes condicions. En aquest cas, però, hi ha més de d’un camí (n’hi ha quatre). A més a més, cal decidir si es compleix una condició diferent per decidir quin és el camí que cal seguir entre totes les opcions. El darrer es du a terme simplement quan no es compleix cap dels anteriors. Per tant, es tracta d’una selecció múltiple.

Un fet destacat en aquesta descripció de les tasques que ha de dur a terme el programa, com a mínim respecte als exemples anteriors, és que per a cada pas possible s’han de complir dues condicions alhora. El valor de la nota ha d’estar per sota de cert valor i per sobre d’un altre. L’expressió de tipus booleà que cal avaluar per veure quin camí cal seguir ha de comprovar totes dues coses: que es compleix una cosa i l’altra. O sigui, cal una expressió lògica basada en la conjunció de dues comparacions. Un cop més, observeu quines instruccions es corresponen a cadascun dels passos descrits. Fixeu-vos en particular en com són les condicions lògiques per a cada cas.

Compileu i executeu el programa següent per veure com la nota mostrada depèn del valor introduït:

import java.util.Scanner;
//Un programa que indica la nota en text a partir de la numèrica.
public class Avaluacio {

  public static void main(String[] args) {

    Scanner lector = new Scanner(System.in);
    System.out.print("Quina nota has tret? ");
    float nota = lector.nextFloat();
    lector.nextLine();
    //Estructura de selecció múltiple.
    //S’entra al bloc on la condició lògica avaluï a true.
    //Si cap no ho fa, s’entra al bloc else.
    System.out.print("La teva nota final és ");
    if ((nota >= 9) && (nota <= 10)) {
       System.out.println("·Excellent.");
    } else if ((nota >= 6.5) && (nota < 9)) {
       System.out.println("Notable.");
    } else if ((nota >= 5) && (nota < 6.5)) {
       System.out.println("Aprovat.");
    } else {
       System.out.println("Suspès.");
    }
    System.out.println("Espero que hagi anat bé...");
  }
}

El diagrama de flux per a aquest programa en concret es mostra tot seguit, a la figura següent. En aquest cas, el codi seguirà un entre cinc camins possibles, tots disjunts.

Una altra possibilitat

El programa que tot just s’ha exposat analitza totes les possibilitats a l’hora d’avaluar les notes de manera molt estricta. Totes les condicions possibles són absolutament disjuntes. Mai no es pot donar el cas que dues avaluïn cert, ja que la nota introduïda pertanyerà a un i només a un dels rangs establerts. Ara bé, la selecció múltiple accepta que les condicions no ho siguin. En cas que se’n compleixi més d’una, el bloc d’instruccions que s’executarà serà el de la primera condició que ha avaluat com a true, per ordre d’escriptura en el codi.

Un cop es té una mica d’experiència programant, es pot jugar amb aquest fet, per plantejar aquest programa d’una altra manera:

1. Demanar que s’introdueixi la nota pel teclat.
2. Llegir-la.
3. Mostrar un text o un altre segons dins de quin rang de valors es troba la nota:
     (a) Si és major o igual que 9, la nota és “Excel·lent”.
     (b) Si és major o igual que 6,5, la nota és “Notable”.
     (c) Si és major o igual que 5, la nota és “Suficient
     (d) Si no és cap dels casos anteriors, la nota és “Suspès”.

En aquest plantejament, l’ordre d’avaluació de les condicions és molt més important.

er a una nota de 9,5 es compleixen totes i cadascuna de les condicions. Però només es durà a terme l’acció relativa a la primera de les enumerades (en aquest cas, la I).

El codi font associat seria el següent, pràcticament idèntic a l’anterior. Compileu-lo i executeu-lo per comprovar que el comportament és el mateix.

import java.util.Scanner;

public class AvaluacioSimplificat {

  public static void main(String[] args) {
    Scanner lector = new Scanner(System.in);
    System.out.print("Quina nota has tret? ");
    float nota = lector.nextFloat();
    lector.nextLine();
    //Estructura de selecció múltiple.
    //S’entra al bloc on la condició lògica avaluï a true.
    //Les condicions s’avaluen per ordre d’aparició.
    //Si cap no ho fa, s’entra al bloc else.
    System.out.print("La teva nota final és ");
    if ((nota >= 9) && (nota <= 10)) {
       System.out.println("Excellent.");
    } else if (nota >= 6.5) {
       System.out.println("Notable.");
    } else if (nota >= 5) {
       System.out.println("Aprovat.");
    } else {
       System.out.println("Suspès.");
    }
    System.out.println("Espero que hagi anat bé...");
  }
}

Combinació d’estructures de selecció

Les sentències que defineixen estructures de selecció són instruccions com qualsevol altre dins d’un programa, si bé amb una sintaxi una mica més complicada.

Per tant, res no impedeix que tornin a aparèixer dins de blocs d’instruccions d’altres estructures de selecció. Això permet crear una disposició de bifurcacions dins el flux de control per tal de dotar al programa d’un comportament complex, per comprovar si es compleixen diferents condicions d’acord amb cada situació.

Exemple: descompte màxim i control d’errors

Per veure un exemple en què resulta útil la combinació d’estructures de selecció, imagineu que voleu fer un parell de modificacions a l’exemple del càlcul d’un descompte. D’una banda, que hi hagi un valor màxim de descompte, de manera que si per algun motiu correspon fer un descompte per sobre d’aquest valor, només s’apliqui el màxim establert. D’altra banda, estaria bé corregir un comportament una mica estrany que ara mateix té el programa: que és capaç d’acceptar preus negatius. En aquest cas, com que és evident que l’usuari s’ha equivocat, estaria bé avisar-lo amb algun missatge.

Ara el programa hauria de fer el següent:

1. Decidir quin és el valor mínim per optar al descompte, quant es descomptarà i el valor màxim possible.

2. Demanar que s’introdueixi el preu inicial, en euros, pel teclat.

3. Llegir-lo.

4. Comprovar que el preu és correcte i no és negatiu:

   (a) Si es compleix, veure si el preu introduït és igual o superior al valor mínim per optar al descompte:

        i. Si és així, calcular el descompte.
        ii. Comprovar si el descompte supera el màxim permissible:
            A. Si és així, el descompte es redueix al màxim permissible.
        iii. Aplicar el descompte sobre el preu inicial.

   (b) Mostrar el preu final.

   (c) Si el preu era negatiu, mostrar un missatge d’error.

Així, doncs, apareixen dues noves condicions. Abans de fer res cal veure si el preu és positiu i, immediatament després de calcular el descompte, cal veure si es compleix la nova condició de si el valor és superior al màxim o no. La articularitat és que ara les diferents condicions del programa només es comproven si les anteriors es van complint, una darrere de l’altra.

El codi següent fa ús d’una combinació d’estructures de selecció per dur a terme aquesta modificació. Compileu-lo i executeu-lo.

public class DescompteControlErrors {

   public static void main(String[] args) {
     // Es fa un descompte del 8%.
     final float DESCOMPTE = 8;
     //Es fa descompte per compres de 100 euros o més.
     final float COMPRA_MIN = 100;
     //Valor del descompte màxim: 20 euros.
     final float DESC_MAXIM = 20;
     Scanner lector = new Scanner(System.in);
     System.out.print("Quin és el preu del producte, en euros? ");
     float preu = lector.nextFloat();
     lector.nextLine();
     // El preu és positiu?
    if (preu > 0) {
       if (preu >= COMPRA_MIN) {
          float descompteFet = preu * DESCOMPTE / 100;
          if (descompteFet > DESC_MAXIM) {
             descompteFet = DESC_MAXIM;
          }
          preu = preu - descompteFet;
       }
       System.out.println("El preu final per pagar és de " + preu + " euros.");
    } else {
           System.out.println("Preu incorrecte. És negatiu.");
    }
   }
}

Un dels aspectes més importants d’aquest exemple és que el programa ha de ser capaç de comprovar si les dades que ha introduït l’usuari compleixen certes condicions i així avisar-lo de possibles errors. Moltes vegades, per aconseguir-ho cal combinar diferents estructures de selecció, de manera que només se segueix pel camí que processa les dades si es pot garantir que són correctes. De fet, tant en l’exemple d’endevinar un nombre com en el de transformar les notes també valdria la pena fer aquesta comprovació, i veure si el valor introduït està realment entre els valors permissibles (0 i 10).

• Les estructures de selecció són fonamentals per poder comprovar si les dades que introdueix l’usuari són correctes abans de processar-les.

• Si una variable es declara dins d’un bloc ( { }) només és visible dintre d’aquest bloc i dels seus blocs “fills”. Per tant fora d’aquests blocs no es podrà utilitzar.

La sentència ”switch”

Hi ha una estructura de selecció una mica especial, motiu pel qual s’ha deixat per al final. El que la fa especial és que no es basa a avaluar una condició lògica composta per una expressió booleana, sinó que estableix el flux de control a partir de l’avaluació d’una expressió de tipus enter o caràcter.

La sentència switch enumera, un per un, un conjunt de valors discrets que es volen tractar, i assigna les instruccions que cal executar si l’expressió avalua en cada valor diferent. Finalment, especifica què cal fer si l’expressió no ha avaluat en cap dels valors enumerats. És com un commutador o una palanca de canvis, en què s’assigna un codi per a cada valor possible que cal tractar. Aquest comportament seria equivalent a una estructura de selecció múltiple en què, implícitament, totes les condicions són comparar si una expressió és igual a cert valor. Cada branca controlaria un valor diferent. El cas final és equivalent a l'else. De fet, en la majoria de casos, aquesta sentència no aporta res des del punt de vista del flux de control que no es pugui fer amb una selecció múltiple. Però és molt útil amb vista a millorar la llegibilitat del codi o facilitar la generació del codi del programa. Ara bé, sí que hi ha un petit detall en què aquesta sentència aporta alguna cosa que la resta d’estructures de selecció no poden fer directament: executar de manera consecutiva més d’un bloc de codi relatiu a diferents condicions.

Sintaxi i comportament

La sintaxi de la sentència switch s’ajusta al format descrit tot seguit. Novament, es basa en una paraula clau seguida d’una condició entre parèntesis i un bloc de codi entre claus. Ara bé, la diferència respecte de les sentències vistes fins ara és que els conjunts d’instruccions assignats a cada cas independent no es distingeixen entre si per claus. Aquests es van enumerant com un conjunt d’apartats etiquetats per la paraula clau case, seguida del valor que es vol tractar i de dos punts. De manera opcional, es pot posar una instrucció especial que serveix de delimitador de final d’apartat, nomenada break. Al final de tots els apartats se’n posa un d’especial (opcional), anomenat default.

switch(expressió de tipus enter, caràcter o text) {
     case valor1:
          instruccions si l’expressió avalua a valor1
          (opcionalment) break;
     case valor2:
          instruccions si l’expressió avalua a valor2
          (opcionalment) break;
     ...
     case valorN:
          instruccions si l’expressió avalua a valorN
          (opcionalment) break;
    (opcionalment ) default:
          instruccions si l’expressió avalua a algun valor que no és valor1...valorN
          (opcionalment) break;
}

En executar la sentència switch s’avalua l’expressió entre parèntesis i immediatament s’executa el conjunt d’instruccions assignat a aquell valor entre els diferents apartats case. Si no n’hi ha cap amb aquest valor entre els disponibles, llavors s’executa l’apartat etiquetat com a default (per defecte).

Cal dir que els valors no han de seguir cap ordre en concret per definir cada apartat. Si bé pot ser més polit enumerar-los per ordre creixent, això no té cap efecte sobre el comportament del programa.

La particularitat especial d’aquesta sentència la tenim en l’ús de la instrucció break. Aquesta indica què cal fer un cop executades les instruccions de l’apartat.

Si apareix la instrucció, el programa se salta la resta d’apartats i continua amb la instrucció posterior a la sentència switch (després de la clau que tanca el bloc). En aquest aspecte, si tots els apartats acaben en break, el funcionament de switch és equivalent a fer:

if (expressió == valor 2) {
      instruccions si l’expressió avalua a valor1
} else if (expressió == valor2) {
      instruccions si l’expressió avalua a valor2
...
} else if (expressió == valorN) {
      instruccions si l’expressió avalua a valorN
} else {
      instruccions si l’expressió avalua a algun valor que no és valor1...valorN
}

Ara bé, si algun dels apartats no acaba en break, en executar la darrera instrucció, en lloc de saltar la resta d’apartats, el que es fa és seguir executant les instruccions de l’apartat que ve immediatament després. Així anirà fent, apartat per apartat, fins trobar-ne algun que acabi en break. La figura següent mostra aquest comportament tan particular.

• A partir de la versió 7 de Java es pot fer servir un String (text) per a avaluar l’expressió