Sentència if-else
La sentència if-else és una construcció que permet a un programa realitzar distintes accions
depenent del valor d'una expressió Booleana. Si és true, el programa realitza unes accions,
en cas contrari, si és false, el programa realitza unes altres operacions. Alguns exemples
de expressións Booleanes són: a > b, i -j == 1, p && q, etc.
La sentència if-else te distintes formes. Anem a veure-les.
if
La forma més simple és la sentència if única. Consisteix en la paraula-clau if, una
expressió Booleana entre parèntesi i un bloc tancat entre claus:
if (expressio) {
// cos: fer alguna cosa
}
Si l'expressió és true, les sentències dintre del bloc s'executen; en cas contrari, el programa
se les salta.
Per exemple:
int edat = ...; // l'edat que sigui
if (edat > 17) {
System.out.println("Pots votar");
}
En aquest exemple, si l'edat és més gran que 17 el codi imprimeix "Pots votar",
en cas contrari, no fa res.
L'expressió també pot ser el valor d'una variable de tipus boolean. Si el valor és true, el
bloc s'executarà, i si és false no.
int edat = ...;
boolean majorEdat = edat > 17;
if (majorEdat) {
System.out.println("Pots votar");
}
Enquesta frameworks
if-else
La sentència if es pot extendre amb la paraula-clau else i un altre bloc per a fer accions
alternatives quan l'expressió és falsa.
if (expressio) {
// fer una cosa
} else {
// fer una altra cosa
}
En aquest cas, quan l'expressió és true, s'executa el primer bloc de codi; en cas contrari s'executa
el segon bloc, però mai els dos.
Al següent exemple, el programa imprimeix texts diferents depenent del valor de num (parell o imparell).
int num = ...; // num s'inicialitza en algun valor
if (num % 2 == 0) {
System.out.println("Nombre parell");
} else {
System.out.println("Nombre imparell");
}
if-else-if
La forma més general de la sentència condicional consisteix en vàries condicions encadenades:
if (expressio0) {
// accions0
} else if (expressio1) {
// accions1
} else if (expressio2) {
// accions2
// ...
} else {
// accions else
}
En aquest cas el programa executa les accions en les que primer es compleix l'expressió. Si cap expressió
es true, aleshores s'executa l'última acció.
El següent exemple recomana l'ordinador que es pot comprar depenent del pressupost.
int pressupost = ...;
if (pressupost < 1000) {
System.out.println("Portatil");
} else if (pressupost < 2000) {
System.out.println("PC");
} else if (pressupost < 100_000) {
System.out.println("Servidor");
} else {
System.out.println("Comprat un data center o un ordinador quantic!");
}
Una sentència condicional amb múlitples branques crea un arbre de decisió, el
qual els seus nodes són expressions booleanes, i cada branca es marca amb true o false.
La branca-true porta a un bloc de sentències i la branca-false porta a comprovar la
següent expressió. L'última branca-false significa "en qualsevol altre cas".
Quan parlem sobre sentències condicionals, sovint els programadors utilitzen el terme
"sentències de control de flux". El control de flux és l'ordre en que s'executen les
diferents parts del programa.
Aquest diagrama il·lustra l'arbre de decisió de l'exemple del pressupost.
Niament de sentències if-else
Les sentències if-else es poden niar (posar unes dintre d'altres). És a dir, en el bloc
d'una condició es poden posar altres if-else, que només seran executades si es compleix la condició (
i per tant s'executa el bloc).
El següent exemple executa un editor específic depenent del Sistema Operatiu i la seva versió:
import java.io.IOException;
import java.util.Scanner;
public class Main {
public static void main(String[] args) throws IOException {
Scanner scanner = new Scanner(System.in);
String os = scanner.nextLine();
String version = scanner.nextLine();
if (os.equals("Ubuntu")) {
System.out.println("Checking Ubuntu version...");
if(version.equals("20.04")) {
Runtime.getRuntime().exec("gedit");
} else if (version.equals("18.04")){
Runtime.getRuntime().exec("nano");
} else {
System.out.println("Ubuntu version not supported");
}
} else if (os.equals("Windows")) {
System.out.println("All Windows versions supported");
if(version.equals("10 Pro")) {
Runtime.getRuntime().exec("notepad.exe");
} else {
Runtime.getRuntime().exec("write.exe");
}
} else {
System.out.println("OS not supported");
}
}
}
Aquest és l'arbre de decisió:
Si val és 50, quina és la sortida d'aquest codi?
if (val == 10) {
System.out.println("val == 10");
} else if (val >= 20 && val < 50) {
System.out.println("20 <= val < 50");
} else {
if (val < 20) {
System.out.println("val < 20");
} else {
System.out.println("val >= 50");
}
}
val < 20
val >= 50
val == 10
20 <= val < 50
Cap d'aquestes
Selecciona l'exemple correcte de la sentència condicional
if i < j {
String a = "Hello";
}
if (i < j):
String a = "Hello";
if (i < j) {
String a = "Hello";
}
if {i < j} (
String a = "Hello";
)
if [i < j]
String a = "Hello";
Selecciona la sortida del programa segons el valor de la variable a.
if (a <= 0) {
if(a == 0) {
System.out.println("a");
} else {
System.out.println("b");
}
}
System.out.print("c");
a = 0
a
ab
ac
c
a = -1
ab
bc
ac
c
a = 1
ab
bc
ac
c
Sentència switch
L'ús més habitual de la sentència switch és quan es necessita realitzar diferents accions en funció del
valor d'una variable o expressió.
Un ús molt típic es dona en les pantalles que mostren un menú d'opcions. Per exemple, escollir diferents accions
en el menú d'un joc. Utilitzant la sentència if-else es pot fer així:
System.out.println("1-Start\n2-Load\n3-Help\n4-Exit"); // es mostra el menu
int action = scanner.nextInt(); // l'usuari escull una opcio
if (action == 1) {
System.out.println("Starting a new game...");
} else if (action == 2) {
System.out.println("Loading a saved game");
} else if (action == 3) {
System.out.println("Displaying help...");
} else if (action == 4) {
System.out.println("Exiting...");
} else {
System.out.println("Unsuitable action, please, try again");
}
Aquest codi es perfectament vàlid, però en cas de que hi hagi moltes branques pot arribar a ser molt dens.
switch, case, default
La sentència switch proporciona una forma d'escollir entre múltiples accions en el cas de que una
variable o expressió tingui un valor o un altre.
Utilitzant la sentència switch el codi anterior es veuria així:
System.out.println("1-Start\n2-Load\n3-Help\n4-Exit"); // es mostra el menu
int action = scanner.nextInt(); // l'usuari escull una opcio
switch (action) {
case 1:
System.out.println("Starting a new game...");
break;
case 2:
System.out.println("Loading a saved game");
break;
case 3:
System.out.println("Displaying help...");
break;
case 4:
System.out.println("Exiting...");
break;
default:
System.out.println("Unsuitable action, please, try again");
}
Tot i que no hem explicat les paraules-clau switch, case, default i break,
et pots fer una idea del que fa el codi.
La forma més general d'utilització de la sentència switch és aquesta:
switch (expressio) {
case valor1:
// fer accio1
break;
case valor2:
// fer accio2
break;
//... altres casos
case valorN:
// fer accio N
break;
default:
// fer accio 'per defecte'
}
switch avalua l'expressió (o variable), i després mira amb quin valor de cada cláusula case coincideix,
i aleshores executa les sentències que hi hagi a partir d'aquí fins que trobi un break. En cas de que l'expressió no
coincideixi amb el valor de cap case, s'executen les sentències que hi hagi al default.
Veiem un exmple d'una aplicació per a un supermercat on els clients escriuen el nom d'un producte i l'aplicació
informa del seu preu:
Scanner scanner = new Scanner(System.in);
System.out.println("Producte: ");
String producte = scanner.nextLine();
switch (producte){
case "Taronjes":
System.out.println("1.55 euros/kilo");
break;
case "Pomes":
System.out.println("2.30 euros/kilo");
break;
case "Peres":
System.out.println("2.30 euros/kilo");
break;
case "Platans":
System.out.println("0.89 euros/kilo");
break;
default:
System.out.println("Producte no disponible");
}
Producte:
Peres
2.30 euros/kilo
Fixa't que en aquest exemple el preu de les Pomes i les Peres és el mateix. Podem simplificar
el switch una mica, així:
switch (producte){
case "Taronjes":
System.out.println("1.55 euros/kilo");
break;
case "Pomes":
case "Peres":
System.out.println("2.30 euros/kilo");
break;
case "Platans":
System.out.println("0.89 euros/kilo");
break;
default:
System.out.println("Producte no disponible");
}
Recorda que s'executen totes les sentències a partir del case que coincideix amb l'expressió fins que es troba
un break, així doncs en el cas de que la variable producte sigui Pomes, també s'executarà
la sentència 7, fins a trobar el break de la línia 8.
A la versió 12 de Java s'incorpora una forma abreujada de la sentència switch que utilitza fletxes ->
en lloc dels dos punts : per a les cláules case. En aquesta nova forma no cal utilitzar break.
El programa anterior es podria escriure així:
switch (producte) {
case "Taronjes" -> System.out.println("1.55 euros/kilo");
case "Pomes", "Peres" -> System.out.println("2.30 euros/kilo");
case "Platans" -> System.out.println("0.89 euros/kilo");
default -> System.out.println("Producte no disponible");
}
Què imprimeix el següent programa?
String foo = "B";
int bar = 0;
switch (foo){
case "A":
bar += 10;
case "B":
bar += 20;
case "C":
bar += 30;
default:
bar += 40;
}
System.out.println(bar);
90
Lletres de l'Scrabble
Saluda en diferents idiomes