Diferència entre revisions de la pàgina «M3 - Programació estructurada / Continguts UF1: Estructura alternativa»

De wikiserver
Dreceres ràpides: navegació, cerca
(Exemple: descompte màxim i control d’errors)
 
(Hi ha 17 revisions intermèdies del mateix usuari que no es mostren)
Línia 1: Línia 1:
 +
==Condicional if==
 +
 +
*Permet decidir si en funció d’una condició cal o no executar una o un conjunt d’instruccions.
 +
 +
<source lang="java">
 +
instruccions del programa
 +
  if (expressió booleana) {
 +
        Instruccions per executar si l’expressió avalua a true (cert)
 +
  }
 +
  resta d’instruccions del programa
 +
</source>
 +
 +
*La condició te dues respostes possibles: Certa o Falsa. Si és certa s’executarà el procediment i sinó no
 +
 +
*S’executarà i la execució continuarà amb les sentencies que hi hagi a continuació del bloc if.
 +
 +
Exemple:
 +
 +
<source lang="java">
 +
import java.util.Scanner;
 +
 +
public class MajorEdat {
 +
 +
  public static void main(String[] args) {
 +
    //Decidir si una persona es major de edat.
 +
    final int MAJOREDAT = 18;
 +
    int edat;
 +
    Scanner lector = new Scanner(System.in);
 +
    System.out.print("Quina edat tens? ");
 +
    edat = lector.nextInt();
 +
    if (edat >= 18){
 +
      System.out.println("Ets major d'edat");
 +
 +
    }
 +
    if (edat < 18){
 +
      System.out.println("Ets menor d'edat");
 +
    }
 +
  }
 +
}
 +
</source>
 +
 +
* Si entre els parèntesis es posa una expressió que no avalua un resultat de tipus booleà, hi haurà un error de compilació.
 +
 +
'''Condicionals else i else if'''
 +
 +
<source lang="java">
 +
import java.util.Scanner;
 +
 +
public class MajorEdat {
 +
 +
  public static void main(String[] args) {
 +
    //Decidir si una persona es major de edat.
 +
    final int MAJOREDAT = 18;
 +
    int edat;
 +
    Scanner lector = new Scanner(System.in);
 +
    System.out.print("Quina edat tens? ");
 +
    edat = lector.nextInt();
 +
    if (edat >= 18){                                // S'executa si la condició de l'if és falsa
 +
      System.out.println("Ets major d'edat"); 
 +
 +
    }
 +
    else{
 +
      System.out.println("Ets menor d'edat");
 +
    }
 +
  }
 +
}
 +
</source>
 +
 +
<source lang="java">
 +
// Si necessitem comprovar un altre valor de l'edat podem utilitzar elif
 +
 +
import java.util.Scanner;
 +
 +
public class MajorEdat {
 +
 +
  public static void main(String[] args) {
 +
    //Decidir si una persona es major de edat.
 +
    final int MAJOREDAT = 18;
 +
    int edat;
 +
    Scanner lector = new Scanner(System.in);
 +
    System.out.print("Quina edat tens? ");
 +
    edat = lector.nextInt();
 +
    if (edat >= 18){                              // S'executa si la condició de l'if és falsa
 +
      System.out.println("Ets major d'edat"); 
 +
 +
    }
 +
    else if (edat >= 16) {                        // es comprova només si la condició de l'if és falsa
 +
      System.out.println("Ets adolescent i menor d'edat");
 +
     
 +
    }
 +
    else{                                        // S'executa només si la condició de l'elif és falsa
 +
      System.out.println("Ets menor d'edat");
 +
    }
 +
  }
 +
}
 +
</source>
 +
 +
*Es poden posar tants else if com necessitem
 +
 +
==La sentència ”switch”==
 +
 +
*Quan l’avaluació d’una expressió és de tipus enter o caràcter.
 +
 +
*Millora la llegibilitat del codi
 +
 +
*Es poden executar de manera consecutiva més d'un bloc.
 +
 +
===Sintaxi i comportament===
 +
 +
*Es basa en una paraula clau seguida d’una condició entre parèntesis i un bloc de codi entre  claus
 +
 +
*La paraula clau '''case''' seguida del valor i de dos punts indica les instruccions assignats a cada cas.
 +
 +
*A paritr del case que avalua a cert s'executaran tots els blocs d'instruccions fins a trobar el delimitador '''break'''.
 +
 +
*Al final de tots els apartats se’n posa un d’especial (opcional), anomenat '''default'''.
 +
 +
<source lang="java">
 +
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;
 +
}
 +
</source>
 +
 +
*Els valors no han de seguir cap ordre concret.
 +
 +
*Quan s'arriba a una sentencia '''break''': el programa se salta la resta d’apartats i continua amb la instrucció posterior a la sentència '''switch'''
 +
 +
*Si no hi ha instrucció '''break''' al final d'un bloc s'executaran les instruccions dels següents blocs fins trobar-ne algun bloc que acabi en '''break'''. La figura següent mostra aquest comportament tan particular.
 +
 +
[[Imatge:m3uf1_switch.png |600px|center| Switch]]
 +
 +
:*A partir de la versió 7 de Java es pot fer servir un String (text) per a avaluar l’expressió
 +
 +
:'''Exemple:''' Traduir un número de mes a text'''
 +
<source lang="java">
 +
public class TraduccioMes {
 +
 +
  public static void main(String[] args) {
 +
      int mes;
 +
      Scanner teclat = new Scanner(System.in);
 +
      System.out.println("Introdueixi el número de mes a traduir: ");
 +
      mes = teclat.nextInt();
 +
      switch (mes) {
 +
        case 1:
 +
            System.out.println("Traducció: Gener\n");
 +
            break;
 +
        case 2:
 +
            System.out.println("Traducció: Febrer\n");
 +
            break;
 +
        case 3:
 +
            System.out.println("Traducció: Març\n");
 +
            break;
 +
        case 4:
 +
            System.out.println("Traducció: Abril\n");
 +
            break;
 +
        case 5:
 +
            System.out.println("Traducció: Maig\n");
 +
            break;
 +
        case 6:
 +
            System.out.println("Traducció: Juny\n");
 +
            break;
 +
        case 7:
 +
            System.out.println("Traducció: Juliol\n");
 +
            break;
 +
        case 8:
 +
            System.out.println("Traducció: Agost\n");
 +
            break;
 +
        case 9:
 +
            System.out.println("Traducció: Setembre\n");
 +
            break;
 +
        case 10:
 +
            System.out.println("Traducció: Octubre\n");
 +
            break;
 +
        case 11:
 +
            System.out.println("Traducció: Novembre\n");
 +
            break;
 +
        case 12:
 +
            System.out.println("Traducció: Desembre\n");
 +
            break;
 +
        default:
 +
            System.out.println("No existeix un mes amb número: " + mes);
 +
      }
 +
  }
 +
}
 +
</source>
 +
<!--
 +
 +
 
==Estructures de selecció==
 
==Estructures de selecció==
  
Línia 355: Línia 555:
  
 
==La sentència ”switch”==
 
==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===
 
===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'''.
 +
 +
<source lang="java">
 +
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;
 +
}
 +
</source>
 +
 +
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:
 +
 +
<source lang="java">
 +
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
 +
}
 +
</source>
 +
 +
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.
 +
 +
[[Imatge:m3uf1_switch.png |600px|center| Switch]]
 +
 +
::*A partir de la versió 7 de Java es pot fer servir un String (text) per a avaluar l’expressió
 +
'''
 +
:Exemple: Traduir un número de mes a text'''
 +
<source lang="java">
 +
public class TraduccioMes {
 +
 +
  public static void main(String[] args) {
 +
      int mes;
 +
      Scanner teclat = new Scanner(System.in);
 +
      System.out.println("Introdueixi el número de mes a traduir: ");
 +
      mes = teclat.nextInt();
 +
      switch (mes) {
 +
        case 1:
 +
            System.out.println("Traducció: Gener\n");
 +
            break;
 +
        case 2:
 +
            System.out.println("Traducció: Febrer\n");
 +
            break;
 +
        case 3:
 +
            System.out.println("Traducció: Març\n");
 +
            break;
 +
        case 4:
 +
            System.out.println("Traducció: Abril\n");
 +
            break;
 +
        case 5:
 +
            System.out.println("Traducció: Maig\n");
 +
            break;
 +
        case 6:
 +
            System.out.println("Traducció: Juny\n");
 +
            break;
 +
        case 7:
 +
            System.out.println("Traducció: Juliol\n");
 +
            break;
 +
        case 8:
 +
            System.out.println("Traducció: Agost\n");
 +
            break;
 +
        case 9:
 +
            System.out.println("Traducció: Setembre\n");
 +
            break;
 +
        case 10:
 +
            System.out.println("Traducció: Octubre\n");
 +
            break;
 +
        case 11:
 +
            System.out.println("Traducció: Novembre\n");
 +
            break;
 +
        case 12:
 +
            System.out.println("Traducció: Desembre\n");
 +
            break;
 +
        default:
 +
            System.out.println("No existeix un mes amb número: " + mes);
 +
      }
 +
  }
 +
}
 +
</source>
  
 
==Control d’errors en l’entrada bàsica mitjançant estructures de selecció==
 
==Control d’errors en l’entrada bàsica mitjançant estructures de selecció==
 +
 +
Les estructures de selecció són especialment útils com a mecanisme per controlar si les dades que ha introduït un usuari són correctes abans d’usar-les dins del programa. Un cop ja sabeu com funcionen, és un bon moment per ampliar les explicacions sobre l’entrada bàsica de dades per teclat, de manera que sigui possible controlar si el valor que s’ha introduït encaixa amb el tipus de dada esperat per a cada instrucció de lectura.
 +
 +
Si es parteix que l’extensió per llegir dades de teclat s’ha inicialitzat anteriorment com sempre:
 +
<pre>
 +
  Scanner lector = new Scanner(System.in);
 +
</pre>
 +
 +
Abans de llegir qualsevol dada introduïda pel teclat, és possible usar les instruccions de la taula següent per establir si la dada que tot just s’ha escrit pel teclat és d’un tipus concret o no. Quan s’usen, l’usuari pot introduir dades pel teclat (el programa s’atura) i s’avalua si el que ha escrit pertany a un tipus de dada o un altre. Aquestes instruccions es consideren expressions booleanes que avaluen com a true si el tipus concorda i com a false si no és el cas. Un cop usada aquesta instrucció, només es podran llegir les dades correctament usant la instrucció lector.next... corresponent al mateix tipus si ha avaluat com a true. Si s’intenta després que hagi avaluat false, l’error d’execució està garantit.
 +
 +
{|border="2" cellpadding="4" cellspacing="0" style="margin: 1em 1em 1em 0; background: #f9f9f9; border: 1px #aaa solid; border-collapse: collapse; font-size: 95%;"
 +
! align="left" width="150 px"; color:Black"|Instrucció
 +
! align="left" width="100 px"; color:Black"|Tipus de dada controlada
 +
|-
 +
|lector.hasNextByte()||byte
 +
|-
 +
|lector.hasNextShort()||short
 +
|-
 +
|lector.hasNextInt()||int
 +
|-
 +
|lector.hasNextLong()||long
 +
|-
 +
|lector.hasNextFloat()||float
 +
|-
 +
|lector.hasNextDouble()||double
 +
|-
 +
|lector.hasNextBoolean()||boolean
 +
|}
 +
 +
La instrucció associada a una cadena de text no existeix, ja que qualsevol dada escrita pel teclat sempre es pot interpretar com a text. Per tant, la lectura mai no pot donar error.
 +
 +
L’exemple anterior amb control d’errors ens quedaria així :
 +
<source lang="java">
 +
public class TraduccioMes {
 +
 +
  public static void main(String[] args) {
 +
      int mes;
 +
      Scanner teclat = new Scanner(System.in);
 +
      System.out.println("Introdueixi el número de mes a traduir: ");
 +
      if (teclat.hasNextInt()) {
 +
        mes = teclat.nextInt();
 +
        switch (mes) {
 +
            case 1:
 +
              System.out.println("Traducció: Gener\n");
 +
              break;
 +
            case 2:
 +
              System.out.println("Traducció: Febrer\n");
 +
              break;
 +
            case 3:
 +
              System.out.println("Traducció: Març\n");
 +
              break;
 +
            case 4:
 +
              System.out.println("Traducció: Abril\n");
 +
              break;
 +
            case 5:
 +
              System.out.println("Traducció: Maig\n");
 +
              break;
 +
            case 6:
 +
              System.out.println("Traducció: Juny\n");
 +
              break;
 +
            case 7:
 +
              System.out.println("Traducció: Juliol\n");
 +
              break;
 +
            case 8:
 +
              System.out.println("Traducció: Agost\n");
 +
              break;
 +
            case 9:
 +
              System.out.println("Traducció: Setembre\n");
 +
              break;
 +
            case 10:
 +
              System.out.println("Traducció: Octubre\n");
 +
              break;
 +
            case 11:
 +
              System.out.println("Traducció: Novembre\n");
 +
              break;
 +
            case 12:
 +
              System.out.println("Traducció: Desembre\n");
 +
              break;
 +
            default:
 +
              System.out.println("No existeix un mes amb número: " + mes);
 +
        }
 +
      } else {
 +
            System.out.println("Introdueix un número enter, inutil!!!");
 +
      }
 +
  }
 +
}
 +
</source>
 +
-->

Revisió de 18:35, 6 oct 2020

Condicional if

  • Permet decidir si en funció d’una condició cal o no executar una o un conjunt d’instruccions.
instruccions del programa
  if (expressió booleana) {
        Instruccions per executar si l’expressió avalua a true (cert)
  }
  resta d’instruccions del programa
  • La condició te dues respostes possibles: Certa o Falsa. Si és certa s’executarà el procediment i sinó no
  • S’executarà i la execució continuarà amb les sentencies que hi hagi a continuació del bloc if.

Exemple:

import java.util.Scanner;

public class MajorEdat {

  public static void main(String[] args) {
    //Decidir si una persona es major de edat.
    final int MAJOREDAT = 18;
    int edat;
    Scanner lector = new Scanner(System.in);
    System.out.print("Quina edat tens? ");
    edat = lector.nextInt();
    if (edat >= 18){
      System.out.println("Ets major d'edat");

    }
    if (edat < 18){
      System.out.println("Ets menor d'edat");
    }
  }
}
  • Si entre els parèntesis es posa una expressió que no avalua un resultat de tipus booleà, hi haurà un error de compilació.

Condicionals else i else if

import java.util.Scanner;

public class MajorEdat {

  public static void main(String[] args) {
    //Decidir si una persona es major de edat.
    final int MAJOREDAT = 18;
    int edat;
    Scanner lector = new Scanner(System.in);
    System.out.print("Quina edat tens? ");
    edat = lector.nextInt();
    if (edat >= 18){                                // S'executa si la condició de l'if és falsa
      System.out.println("Ets major d'edat");  

    }
    else{
      System.out.println("Ets menor d'edat");
    }
  }
}
// Si necessitem comprovar un altre valor de l'edat podem utilitzar elif

import java.util.Scanner;

public class MajorEdat {

  public static void main(String[] args) {
    //Decidir si una persona es major de edat.
    final int MAJOREDAT = 18;
    int edat;
    Scanner lector = new Scanner(System.in);
    System.out.print("Quina edat tens? ");
    edat = lector.nextInt();
    if (edat >= 18){                              // S'executa si la condició de l'if és falsa
      System.out.println("Ets major d'edat");  

    }
    else if (edat >= 16) {                        // es comprova només si la condició de l'if és falsa
      System.out.println("Ets adolescent i menor d'edat");
      
    }
    else{                                         // S'executa només si la condició de l'elif és falsa
      System.out.println("Ets menor d'edat");
    }
  }
}
  • Es poden posar tants else if com necessitem

La sentència ”switch”

  • Quan l’avaluació d’una expressió és de tipus enter o caràcter.
  • Millora la llegibilitat del codi
  • Es poden executar de manera consecutiva més d'un bloc.

Sintaxi i comportament

  • Es basa en una paraula clau seguida d’una condició entre parèntesis i un bloc de codi entre claus
  • La paraula clau case seguida del valor i de dos punts indica les instruccions assignats a cada cas.
  • A paritr del case que avalua a cert s'executaran tots els blocs d'instruccions fins a trobar el delimitador 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;
}
  • Els valors no han de seguir cap ordre concret.
  • Quan s'arriba a una sentencia break: el programa se salta la resta d’apartats i continua amb la instrucció posterior a la sentència switch
  • Si no hi ha instrucció break al final d'un bloc s'executaran les instruccions dels següents blocs fins trobar-ne algun bloc que acabi en break. La figura següent mostra aquest comportament tan particular.
Switch
  • A partir de la versió 7 de Java es pot fer servir un String (text) per a avaluar l’expressió
Exemple: Traduir un número de mes a text
public class TraduccioMes {

   public static void main(String[] args) {
      int mes;
      Scanner teclat = new Scanner(System.in);
      System.out.println("Introdueixi el número de mes a traduir: ");
      mes = teclat.nextInt();
      switch (mes) {
         case 1:
            System.out.println("Traducció: Gener\n");
            break;
         case 2:
            System.out.println("Traducció: Febrer\n");
            break;
         case 3:
            System.out.println("Traducció: Març\n");
            break;
         case 4:
            System.out.println("Traducció: Abril\n");
            break;
         case 5:
            System.out.println("Traducció: Maig\n");
            break;
         case 6:
            System.out.println("Traducció: Juny\n");
            break;
         case 7:
            System.out.println("Traducció: Juliol\n");
            break;
         case 8:
            System.out.println("Traducció: Agost\n");
            break;
         case 9:
            System.out.println("Traducció: Setembre\n");
            break;
         case 10:
            System.out.println("Traducció: Octubre\n");
            break;
         case 11:
            System.out.println("Traducció: Novembre\n");
            break;
         case 12:
            System.out.println("Traducció: Desembre\n");
            break;
        default:
            System.out.println("No existeix un mes amb número: " + mes);
      }
   }
}