> For the complete documentation index, see [llms.txt](https://educacion.gitbook.io/programacion/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://educacion.gitbook.io/programacion/ud2-programacion-estructurada/estructuras-condicionais/switch.md).
# Switch
#### Versión clásica de switch:link:
Java dispón da sentenza `switch`:copy:. A súa sintaxe é a seguinte:
```java
switch (expresion){
case valor1:
// bloque de instrucions 1
case valor22:
// bloque de instrucions 2
...
case valorN:
// bloque de instrucions n
default:
// bloque de instrucions por defecto
}
```
A avaliación da **expresión** debe dar un resultado enteiro, convertible a enteiro ou valor de tipo `String`:copy:. A cláusula `default`:copy: é opcional. A dinámica do `switch`:copy: é a seguinte:
Vemos un exemplo sinxelo:
```java
int a = 8;
switch(a){
case 1:
System.out.print("a");
case 5:
System.out.print("b");
case 8:
System.out.print("c");
case 9:
System.out.print("d");
case 11:
System.out.print("e");
default:
System.out.print("f");
}
```
1. Avaliamos a expresión principal: neste caso o resultado é 8.
2. Comprobamos un a un o valor de cada `case`. Neste caso só o terceiro `case` leva asociado o valor 8.
3. Execútase o conxunto de instrucións dende o terceiro `case` ata o final. Polo tanto imprímese: `cdef`.
Como pode verse, dependendo da orde na que coloquemos as cláusulas `case` executaranse unhas instrucións ou outras.
Se queremos que só se execute un bloque debemos utilizar a sentenza `break` tras cada bloque de instrucións.
```java
switch (expresion){
case valor1:
// bloque de instrucions 1
break;
case valor22:
// bloque de instrucions 2
break;
...
case valorN:
// bloque de instrucions n
break;
default:
// bloque de instrucions por defecto
break;
}
```
[](https://java-6cfe38.gitlab.io/03condicionais/03switch/index.html#R-image-98921564c792d0cc1bd0ddfcab54587b)
Vemos un exemplo sinxelo:
```java
int a = 8;
switch(a){
case 1:
System.out.print("a");
break;
case 5:
System.out.print("b");
break;
case 8:
System.out.print("c");
break;
case 9:
System.out.print("d");
break;
case 11:
System.out.print("e");
break;
default:
System.out.print("f");
break;
}
```
Deste xeito só se imprimiría: `c`.
## Tipos de datos admitidos
| Tipo | ¿Podese usar? | Desde versión |
| ---------------------------------------------------- | ------------- | ------------- |
| `byte`, `short`, `int`, `char` | ✅ | Sempre |
| `enum` | ✅ | Java 5 |
| `String` | ✅ | Java 7 |
| `Integer`, `Character`, `Byte`, `Short` (autoboxing) | ✅ | Java 5 |
| `long`, `float`, `double`, `boolean`, obxetos | ❌ | Nom permitido |
Un exemplo da utilización de switch coa clase String:
```java
String animal = "Gato";
switch(animal) {
case "Perro":
System.out.print("El perro ladra");
break;
case "Gato":
System.out.println("El gato maulla");
break;
default:
System.out.print("Animal desconocido");
break;
}
```
#### Versión moderna de switch:link:
O `switch`:copy: moderno en Java, introducido en **Java 12** e estabilizado en **Java 14**, mellora o tradicional `switch`:copy: en varios aspectos:
* Pode devolver valores directamente, o que permite utilizalo como expresión.
* Usa a sintaxe de `case ->`:copy:, que evita o uso de `break`.
* Permite múltiples valores no mesmo `case`.
* Pode executar bloques de código con `{ }` e usar `yield` para devolver valores.
Un `switch`:copy: agora pode asignar directamente un valor a unha variable:
```java
public class SwitchExpressionExample {
public static void main(String[] args) {
String dia = "Luns";
String tipo = switch (dia) {
case "Sábado", "Domingo" -> "Fin de semana";
case "Luns", "Martes", "Mércores", "Xoves", "Venres" -> "Día laborable";
default -> "Descoñecido";
};
System.out.println(tipo);
}
}
```
Non se usa `break`, xa que cada caso usa `->` para devolver directamente o valor. Un `case` pode conter varias opcións separadas por comas. O `default`:copy: segue sendo necesario se non se cobren todas as opcións.
Se precisamos máis lóxica antes de devolver o valor, podemos usar `{ }` e `yield`:
```java
public class SwitchWithBlock {
public static void main(String[] args) {
int puntuacion = 85;
String cualificacion = switch (puntuacion / 10) {
case 10, 9 -> "Excelente";
case 8 -> "Moi Ben";
case 7 -> "Ben";
case 6 -> "Suficiente";
case 5, 4, 3, 2, 1, 0 -> {
System.out.println("Necesitas mellorar.");
yield "Insuficiente"; // `yield` devolve o valor
}
default -> "Erro";
};
System.out.println(cualificacion);
}
}
```
O bloque `{ }` permite executar varias liñas de código dentro dun `case`. O `yield` substitúe a `return`:copy: para devolver un valor dentro de `switch`:copy:.
Se non necesitamos devolver un valor, podemos usar `switch`:copy: tradicional pero mellorado:
```java
public class SwitchStatementExample {
public static void main(String[] args) {
String comando = "START";
switch (comando) {
case "START" -> System.out.println("Iniciando o sistema...");
case "STOP" -> System.out.println("Parando o sistema...");
case "PAUSE" -> System.out.println("Sistema en pausa.");
default -> {
System.out.println("Comando descoñecido.");
}
}
}
}
```
:copy:
A sintaxe `case "START" ->`:copy: fai que o código sexa máis limpo e non precisa `break`.
---
# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.
## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.
Perform an HTTP GET request on the current page URL with the `ask` query parameter:
```
GET https://educacion.gitbook.io/programacion/ud2-programacion-estructurada/estructuras-condicionais/switch.md?ask=
```
The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.
Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.