PROGRAMACIÓN EN JAVA

Tema 2
Variables · Tipos · Operadores · Control de flujo · Arrays · Strings

Ciclo Superior DAW

■ Desarrollo de Aplicaciones Web

Módulo
■ Programación — Solo Java

Contenido
■ Guía completa, clara y práctica para principiantes

■ CONTENIDO DEL TEMA

Variables y Constantes en Java
1 Variables primitivas, de referencia, ámbito, conversiones

Tipos de Datos
2 Primitivos, conversiones, casting

Operadores y Comentarios
3 Aritméticos, lógicos, relacionales, ternario, comentarios

Entrada de Datos (Scanner)

4 Clase Scanner, métodos, errores típicos

Condicionales y Bucles
5 if/else, switch, while, do-while, for
 Strings en Java
6 Métodos, comparación, inmutabilidad

Arrays en Java
7 Declaración, recorrido, clase Arrays

Código Limpio
8 Buenas prácticas, nombres, comentarios

Programación en Java — Tema 2 — DAW Pág. 2

 CAPÍTULO 1

■ Variables y Constantes en Java

¿Qué es una variable?

Una variable es un espacio en la memoria del ordenador donde guardamos un dato. Tiene un nombre (para
referirnos a ella), un tipo (qué clase de dato guarda) y un valor (el dato en sí, que puede cambiar mientras el
programa se ejecuta).

■ Analogía fácil
Piensa en una variable como una caja etiquetada. La etiqueta es el nombre, el tipo indica qué cabe dentro (solo
números, solo texto…) y el valor es lo que hay dentro.

Tipos de variables según su contenido

Categoría Tipos en Java Ejemplo

Tipos primitivos (datos

byte, short, int, long, float, double, char, boolean int edad = 25;
simples)

Tipos de referencia
String, Arrays, Clases, Interfaces String nombre = "Ana";
(objetos)

Tipos de variables según si cambian

Tipo Descripción Ejemplo

Variable Su valor puede cambiar durante el programa int puntos = 0; → puntos = 10;

Constante (final) Su valor NO puede cambiar una vez asignado final int MAX = 100;

¿Cómo declaramos e inicializamos una variable?

La sintaxis básica es: tipo nombre = valor;

// Declarar e inicializar en la misma línea

int edad = 20;
double precio = 9.99;
boolean aprobado = true;
char letra = 'A';
// Declarar primero y asignar después
int suma;
suma = 15;
// Varias variables del mismo tipo en una línea

Programación en Java — Tema 2 — DAW Pág. 3

 int a = 1, b = 2, c = 3;
// Constante: usa final y nombre en MAYÚSCULAS
final int VELOCIDAD_MAXIMA = 120;
final double IVA = 0.21;

Normas para los nombres (identificadores)

Regla Ejemplo correcto Ejemplo incorrecto

Empieza siempre por letra edad 2edad ■

Usa camelCase para palabras

totalCompra total_compra (válido pero menos elegante)
compuestas

Constantes en MAYÚSCULAS con

MAX_INTENTOS maxIntentos ■
_

No usar palabras reservadas de

miClase class ■
Java

Sin espacios ni caracteres raros esValido es valido ■

Ámbito (scope): ¿dónde existe la variable?

Una variable solo existe dentro del bloque { } donde fue declarada. Fuera de ese bloque, Java no la conoce
y dará error.

public class EjemploAmbito {

int variableDeClase = 5; // Existe mientras exista el objeto
public void miMetodo() {
int variableLocal = 10; // Solo existe dentro de este método
[Link](variableLocal); // OK
}
// Aquí variableLocal ya NO existe
}

Valores por defecto

■■ Importante
Las variables de clase (fuera de métodos) se inicializan solas con un valor por defecto. Las variables locales
(dentro de métodos) NO tienen valor por defecto: hay que inicializarlas antes de usarlas o Java dará error.

Tipo Valor por defecto

Numéricos (int, double, etc.) 0 / 0.0

boolean false

char carácter nulo '\u0000'

Programación en Java — Tema 2 — DAW Pág. 4

 Referencias (String, arrays...) null

Conversiones entre tipos

Tipo de conversión Descripción Ejemplo

De tipo pequeño a tipo grande. Java lo

Promoción (automática) int → double (seguro)
hace solo.

Contracción (casting De tipo grande a tipo pequeño. Puede

double → int (puede truncar decimales)
manual) perder datos.

Al asignar directamente una variable a

Por asignación double x = n; (n es int)
otra

En operaciones con tipos distintos, Java

Aritmética int + double → resultado double
convierte automáticamente

// Promoción (automática, sin riesgo)

int n = 25;
double x = n; // x = 25.0 — Java convierte solo
// Contracción (casting manual — cuidado con la pérdida de datos)
double precio = 82.9;
int entero = (int) precio; // entero = 82 — se pierden los decimales
// Casting con paréntesis: (tipo) variable
int a = (int) 3.99; // a = 3

Programación en Java — Tema 2 — DAW Pág. 5

 CAPÍTULO 2

■■ Tipos de Datos en Java

Los 8 tipos primitivos

Java tiene 8 tipos de datos básicos que almacenan un único valor. Son los bloques de construcción más
pequeños de cualquier programa.

Tipo Tamaño Rango / Valores Uso típico Ejemplo

byte 1 byte −128 a 127 Datos muy pequeños byte b = 100;

short 2 bytes −32.768 a 32.767 Enteros pequeños short s = 1000;

int 4 bytes ±2.147 millones Enteros (el más usado) int edad = 20;

long 8 bytes ±9.2 × 10¹■ Números muy grandes long n = 123456789L;

float 4 bytes ±3.4 × 10³■ (6-7 dec.) Decimales (menos prec.) float f = 3.14f;

double 8 bytes ±1.8 × 10³■■ (15 dec.) Decimales (el más usado) double d = 9.99;

char 2 bytes 0 a 65.535 (Unicode) Un carácter char c = 'A';

boolean — true / false Condiciones lógicas boolean ok = true;

■ ¿Cuál usar?
Para enteros: usa int por defecto. Para decimales: usa double por defecto. Para texto: usa String (que no es
primitivo, pero es el más usado). Solo usa los demás cuando tengas un motivo concreto (ahorro de memoria,
rangos específicos).

Tipos de referencia (no primitivos)

Los tipos de referencia no guardan el valor directamente, sino una dirección de memoria donde se
encuentra el objeto. El ejemplo más común es String.

Tipo ¿Tamaño fijo? Descripción

String No Cadena de texto. Depende de la longitud del texto.

Arrays No Colección de datos del mismo tipo. Depende del número de elementos.

Objetos (clases) No Instancias de clases. Depende de sus atributos.

Programación en Java — Tema 2 — DAW Pág. 6

 CAPÍTULO 3

■■ Operadores y Comentarios

Operadores aritméticos
Operador Nombre Ejemplo Resultado

+ Suma 5+3 8

- Resta 8-2 6

* Multiplicación 4*3 12

/ División 10 / 2 5

% Módulo (resto) 7%2 1 (porque 7 = 3×2 + 1)

■■ División entera vs. decimal

Si divides dos int, el resultado es int (se truncan los decimales): 7/2 = 3, no 3.5. Para obtener decimales, al
menos uno debe ser double: 7.0/2 = 3.5

Operadores de incremento y decremento

int x = 5;
int y = ++x; // PRE-incremento: primero suma, luego asigna → x=6, y=6
int a = 5;
int b = a++; // POST-incremento: primero asigna, luego suma → a=6, b=5

Operadores relacionales (comparación)

Siempre devuelven true o false.

Operador Significado Ejemplo Resultado

== Igual a 5 == 5 true

!= Distinto de 5 != 3 true

> Mayor que 8>3 true

< Menor que 2<1 false

>= Mayor o igual 5 >= 5 true

<= Menor o igual 3 <= 2 false

Programación en Java — Tema 2 — DAW Pág. 7

 ■ Error muy común
Nunca uses = cuando quieres comparar. El signo = es asignación. Para comparar usa ==. Ejemplo malo: if
(edad = 18) → Ejemplo correcto: if (edad == 18)

Operadores lógicos
Operador Nombre Descripción Ejemplo

&& AND (Y) true solo si AMBAS condiciones son true edad >= 18 && tieneCarnet

|| OR (O) true si AL MENOS UNA condición es true esDia || esNoche

! NOT (NO) Invierte el valor lógico !aprobado

Operador ternario
Es una forma compacta de escribir un if-else simple. La estructura es: condicion ? valorSiTrue :
valorSiFalse

// En lugar de esto:
int mayor;
if (a > b) { mayor = a; } else { mayor = b; }
// Puedes escribir esto (mismo resultado):
int mayor = (a > b) ? a : b;
// Otro ejemplo:
String resultado = (nota >= 5) ? "Aprobado" : "Suspenso";

Prioridad de operadores
Java evalúa las expresiones en este orden (de mayor a menor prioridad):

Prioridad Operadores

1 (mayor) ( ) — paréntesis

2 ++ -- !

3 */%

4 +-

5 < > <= >=

6 == !=

7 &&

8 ||

9 (menor) = (asignación)

Programación en Java — Tema 2 — DAW Pág. 8

 ■ Consejo profesional
Cuando tengas dudas, usa paréntesis. Son gratis y evitan errores: if ((edad >= 18 && edad <= 65) ||
esEstudiante)

Comentarios en Java
Los comentarios son texto que Java ignora completamente. Sirven para explicar el código y facilitar su
mantenimiento.

// Comentario de una sola línea → para explicaciones cortas

int edad = 18; // edad mínima para votar
/* Comentario multilínea
Útil para explicar bloques de código
o poner descripciones largas */
/**
* Comentario JavaDoc → para documentar clases y métodos
* @param a primer número
* @param b segundo número
* @return la suma de ambos
*/
public int sumar(int a, int b) { return a + b; }

■ Regla de oro de los comentarios

Comenta el PORQUÉ, no el QUÉ. Si el código dice `contador++`, no escribas `// suma 1`. Escribe: `//
avanzamos al siguiente alumno`. El código explica el qué; el comentario explica el porqué.

Programación en Java — Tema 2 — DAW Pág. 9

 CAPÍTULO 4

■■ Entrada de Datos por Teclado — Scanner

¿Qué es Scanner?
Scanner es una clase de Java que permite leer lo que el usuario escribe por teclado. Está en el paquete
[Link], así que hay que importarla antes de usarla.

import [Link]; // ← SIEMPRE al principio del archivo

public class MiPrograma {

public static void main(String[] args) {
Scanner teclado = new Scanner([Link]); // Crear el Scanner
// ... leer datos ...
[Link](); // Cerrar al final (buena práctica)
}
}

Métodos principales de Scanner

Método ¿Qué lee? Ejemplo de uso

nextInt() Un número entero (int) int n = [Link]();

nextDouble() Un número decimal (double) double precio = [Link]();

Una palabra (hasta el primer

next() String nombre = [Link]();
espacio)

nextLine() Una línea completa (con espacios) String frase = [Link]();

nextBoolean() true o false boolean ok = [Link]();

next().charAt(0) Un carácter individual char letra = [Link]().charAt(0);

El problema clásico del buffer

■ Bug muy frecuente
Cuando usas nextInt() o nextDouble(), el Enter que el usuario pulsa queda pendiente en memoria. Si a
continuación usas nextLine(), leerá ese Enter vacío en lugar del texto que escriba el usuario.

// ■ PROBLEMA
int edad = [Link]();
String nombre = [Link](); // Lee una línea vacía. ¡Bug!
// ■ SOLUCIÓN: limpiar el buffer con nextLine() extra

Programación en Java — Tema 2 — DAW Pág. 10

 int edad = [Link]();
[Link](); // consume el Enter pendiente
String nombre = [Link](); // ahora sí lee correctamente

Ejemplo completo con Scanner

import [Link];

public class EntradaDatos {

public static void main(String[] args) {
Scanner teclado = new Scanner([Link]);
[Link]("Introduce tu nombre: ");
String nombre = [Link]();
[Link]("Introduce tu edad: ");
int edad = [Link]();
[Link](); // limpiar buffer
[Link]("Introduce tu nota: ");
double nota = [Link]();
[Link]("Nombre: " + nombre);
[Link]("Edad: " + edad);
[Link]("Nota: " + nota);
[Link]();
}
}

Métodos de validación (hasNextX)

Antes de leer, puedes comprobar si lo que el usuario escribió es del tipo correcto:

Método Comprueba si hay...

hasNextInt() Un entero válido pendiente

hasNextDouble() Un decimal válido pendiente

hasNext() Cualquier token (palabra)

hasNextLine() Una línea pendiente

Errores típicos con Scanner

Error Consecuencia Solución

No importar Scanner Error de compilación Añadir import [Link];

Usar next() para frases Solo lee una palabra Usar nextLine()

No limpiar el buffer Lee líneas vacías Añadir [Link]() extra

Programación en Java — Tema 2 — DAW Pág. 11

 El usuario escribe texto donde Excepción
Validar con hasNextInt()
espera número InputMismatchException

Programación en Java — Tema 2 — DAW Pág. 12

 CAPÍTULO 5

■ Condicionales y Bucles

PARTE A — Condicionales
Los condicionales permiten que el programa tome decisiones: ejecutar un bloque de código u otro según
una condición.

if / else if / else

int nota = 8;

if (nota < 0 || nota > 10) {

[Link]("Nota no válida"); // Primero validamos
} else if (nota < 5) {
[Link]("Suspenso");
} else if (nota < 7) {
[Link]("Aprobado");
} else if (nota < 9) {
[Link]("Notable");
} else {
[Link]("Sobresaliente");
}

switch (para valores exactos)

Usa switch cuando comparas una variable contra varios valores concretos (ideal para menús).

int opcion = 2;

switch (opcion) {
case 1:
[Link]("Alta de usuario");
break; // ← MUY IMPORTANTE: sin break, continúa al siguiente caso
case 2:
[Link]("Login");
break;
case 3:
[Link]("Salir");
break;
default: // Se ejecuta si ningún case coincide
[Link]("Opción no válida");
}

Programación en Java — Tema 2 — DAW Pág. 13

 Tabla resumen — ¿cuándo usar cada uno?
Estructura ¿Cuándo usarla? Ejemplo típico

if Una sola condición simple Validar si un número es positivo

if–else Dos caminos (correcto/incorrecto) Login: acceso permitido o denegado

if–else if–else Varios rangos o condiciones Clasificar una nota

Un valor entre varias opciones

switch Menú de opciones 1,2,3...
exactas

PARTE B — Bucles
Los bucles permiten repetir un bloque de código varias veces. Java tiene tres tipos: while, do-while y for.

while — repetir mientras la condición sea true

// Se usa cuando NO sabes cuántas veces se repetirá

int edad = -5;
while (edad < 0 || edad > 120) { // Condición al principio
[Link]("Edad inválida");
edad = 25; // En un programa real: leerías con Scanner
}
[Link]("Edad aceptada: " + edad);

do-while — se ejecuta AL MENOS una vez

// Perfecto para menús: siempre se muestra al menos una vez

int opcion;
do {
[Link]("1) Alta 2) Login 0) Salir");
opcion = [Link](); // leer opción
} while (opcion != 0); // Condición al final

[Link]("Programa finalizado.");

for — cuando sabes cuántas veces repetir

// Estructura: for (inicio; condición; actualización)

for (int i = 1; i <= 10; i++) {
[Link]("i = " + i);
}
// Ejemplo útil: 3 intentos de login
boolean acceso = false;
for (int intento = 1; intento <= 3; intento++) {
String pass = [Link]();

Programación en Java — Tema 2 — DAW Pág. 14

 if ([Link]("admin123")) {
acceso = true;
break; // Salimos del bucle porque ya no necesitamos más intentos
}
}
[Link](acceso ? "Acceso concedido" : "Cuenta bloqueada");

Tabla resumen — ¿qué bucle usar?

Bucle Cuándo usarlo Ejemplo DAW típico

Repetir hasta que el dato sea válido (no sabes

while Validar entrada del usuario
cuántas veces)

Mostrar menú que se repite hasta que el usuario

do-while Menú de consola
salga

for Número de repeticiones conocido de antemano 3 intentos de login, recorrer array

Errores típicos con bucles

Error Consecuencia Solución

No modificar la variable de la Bucle infinito (el programa

Asegúrate de actualizar la variable
condición se cuelga)

Usar i <= [Link] en ArrayIndexOutOfBoundsEx

Los arrays van de 0 a length-1
vez de i < [Link] ception

Se ejecutan todos los case

Olvidar el break en switch Añadir break al final de cada case
siguientes

Programación en Java — Tema 2 — DAW Pág. 15

 CAPÍTULO 6

■ Strings en Java

¿Qué es un String?
Un String es un objeto (no primitivo) que representa una cadena de texto. Es inmutable: una vez creado, no
se puede cambiar. Los métodos que parecen modificarlo en realidad devuelven un String nuevo.

String texto = "Hola Java";

// La inmutabilidad en acción:
String mayusculas = [Link]();
[Link](texto); // Sigue siendo "Hola Java" (no cambió)
[Link](mayusculas); // "HOLA JAVA" (nuevo String)

Comparar Strings — Regla de oro

■ NUNCA uses == para comparar texto
El operador == compara si dos variables apuntan al mismo objeto en memoria, no si tienen el mismo texto.
Para comparar contenido, usa siempre equals().

String a = "hola";
String b = "hola";
[Link](a == b); // Puede dar false (compara objetos)
[Link]([Link](b)); // true ■ (compara contenido)
[Link]([Link](b)); // true ■ (ignora mayúsculas)

Métodos más importantes de String

Método ¿Qué hace? Ejemplo

length() Longitud (número de caracteres) "Hola".length() → 4

isEmpty() ¿Está vacío? "".isEmpty() → true

charAt(i) Carácter en posición i (desde 0) "Hola".charAt(1) → 'o'

Subcadena desde a hasta antes

substring(a, b) "Hola".substring(1,3) → "ol"
de b

Posición de la primera aparición

indexOf(x) "Hola".indexOf('l') → 2
de x

lastIndexOf(x) Posición de la última aparición "Hola".lastIndexOf('l') → 3

Programación en Java — Tema 2 — DAW Pág. 16

 startsWith(x) ¿Empieza por x? "Hola".startsWith("Ho") → true

endsWith(x) ¿Termina por x? "Hola".endsWith("la") → true

replace(a, b) Reemplaza a por b (nuevo String) "casa".replace('a','e') → "cese"

replaceAll(regex, b) Reemplaza con expresión regular "hola".replaceAll("[aeiou]","*") → "h*l*"

toUpperCase() Convierte a mayúsculas "hola".toUpperCase() → "HOLA"

toLowerCase() Convierte a minúsculas "HOLA".toLowerCase() → "hola"

trim() Elimina espacios al inicio y al final " hola ".trim() → "hola"

contains(x) ¿Contiene la cadena x? "Hola".contains("ol") → true

toCharArray() Convierte a array de char "Hi".toCharArray() → ['H','i']

[Link](x) Convierte cualquier valor a String [Link](42) → "42"

Concatenación de Strings
String nombre = "Ana";
int edad = 25;
// Con el operador + (más cómodo)
String mensaje = "Me llamo " + nombre + " y tengo " + edad + " años.";
[Link](mensaje);
// Resultado: Me llamo Ana y tengo 25 años.

// Java convierte automáticamente tipos a String al concatenar con +

Programación en Java — Tema 2 — DAW Pág. 17

 CAPÍTULO 7

■ Arrays en Java

¿Qué es un array?
Un array es una estructura que guarda muchos valores del mismo tipo bajo un único nombre. Accedes a
cada elemento por su índice (posición), que siempre empieza en 0.

■ Analogía
Imagina una fila de taquillas numeradas del 0 al N-1. Todas guardan el mismo tipo de cosa (solo números, solo
nombres…). Para abrir una taquilla usas su número (el índice).

Declarar, crear e inicializar un array

// 1. Solo declarar (aún no hay memoria reservada)
int[] notas;
// 2. Crear con new (reserva memoria, todos los valores se inicializan a 0)
notas = new int[5]; // array de 5 enteros
// 3. Declarar y crear en una línea
int[] notas = new int[5];
// 4. Declarar con valores directamente (la forma más común)
int[] notas = {8, 7, 9, 5, 10};
// notas[0]=8, notas[1]=7, notas[2]=9, notas[3]=5, notas[4]=10

Acceder a los elementos

int[] a = {10, 20, 30, 40, 50};

[Link](a[0]); // 10 (primer elemento)

[Link](a[4]); // 50 (último elemento)
a[2] = 99; // modificar el elemento en posición 2
// Longitud del array (atributo, sin paréntesis)
[Link]([Link]); // 5
// ■■ Si usas un índice que no existe → ArrayIndexOutOfBoundsException
// [Link](a[5]); ← ERROR: los índices van de 0 a 4

Recorrer un array
int[] numeros = {4, 5, 2, 9, 1};

// Opción 1: for clásico (cuando necesitas el índice)

for (int i = 0; i < [Link]; i++) {

Programación en Java — Tema 2 — DAW Pág. 18

 [Link]("Posición " + i + ": " + numeros[i]);
}
// Opción 2: for-each (más limpio, cuando no necesitas el índice)
for (int valor : numeros) {
[Link](valor);
}

Arrays y referencias — ¡cuidado!

■■ Un array es una referencia
Cuando haces b = a (siendo ambos arrays), NO copias los elementos. Ambas variables apuntan al mismo
array. Si modificas b, también modificas a.

int[] a = {3, 3, 3};

int[] b = a; // b NO es una copia, apunta al mismo array
b[0] = 8;
[Link](a[0]); // 8 — ¡a también cambió!
// Para copiar de verdad, usa [Link]:
int[] copia = [Link](a, [Link]);

La clase [Link]
Java incluye la clase Arrays con métodos listos para usar. Solo tienes que importarla: import
[Link];

Método ¿Para qué sirve? Ejemplo

[Link](a) Muestra el array como texto legible [Link](a) → "[1, 2, 3]"

[Link](a) Ordena de menor a mayor [Link](a)

[Link](a, v) Rellena todo el array con el valor v [Link](a, -1)

Compara el contenido de dos

[Link](a, b) [Link](a,b) → true/false
arrays

[Link](a, n) Crea una copia de longitud n [Link](a, [Link])

[Link](a, i, j) Copia solo de i a j-1 [Link](a, 2, 5)

Busca v en array ORDENADO,

[Link](a, v) [Link](a, 8)
devuelve índice

Arrays multidimensionales (matrices)

// Array bidimensional: 3 filas, 4 columnas
int[][] matriz = new int[3][4];
matriz[0][0] = 9; // fila 0, columna 0
// Con valores directamente

Programación en Java — Tema 2 — DAW Pág. 19

 int[][] tabla = { {1,2,3}, {4,5,6}, {7,8,9} };
// Recorrer con doble bucle for
for (int i = 0; i < [Link]; i++) {
for (int j = 0; j < tabla[i].length; j++) {
[Link](tabla[i][j] + " ");
}
[Link](); // salto de línea al terminar cada fila
}

Programación en Java — Tema 2 — DAW Pág. 20

 CAPÍTULO 8

■ Código Limpio en Java — Clean Code

¿Por qué importa el código limpio?

■ Idea clave
El código se lee muchas más veces de las que se escribe. Código limpio no es 'código bonito': es código fácil
de leer, mantener y ampliar.

Nombres profesionales
Elemento Convención Ejemplo correcto Ejemplo malo

Variables camelCase, descriptivo edadUsuario, precioTotal x, pt, dato1

MAYÚSCULAS_CON_GUI EDAD_MINIMA,
Constantes maximo, iva
ON IVA_REDUCIDO

camelCase, verbo + calcularTotal(),

Métodos calc(), doIt()
sustantivo validarEmail()

Clases PascalCase, sustantivo Cliente, FacturaService cosa, mi_clase

Estilo y formato
// ■ CORRECTO: espacios, llaves consistentes, indentación
if (condicion) {
ejecutar();
} else {
alternativa();
}
int total = precio + envio;
for (int i = 0; i < n; i++) { ... }
// ■ MAL: sin espacios, ilegible
if(condicion){ejecutar();}else{alternativa();}
int total=precio+envio;

Evitar números mágicos

// ■ MAL: ¿qué significa 18? ¿qué significa 0.21?
if (edad >= 18) { ... }
double impuesto = precio * 0.21;

Programación en Java — Tema 2 — DAW Pág. 21

 // ■ BIEN: usa constantes con nombres claros
public static final int EDAD_MINIMA = 18;
public static final double IVA = 0.21;
if (edad >= EDAD_MINIMA) { ... }
double impuesto = precio * IVA;

Checklist antes de entregar tu código

■ ¿Los nombres de variables y métodos son claros y descriptivos?
■ ¿Los métodos son cortos y tienen una sola responsabilidad?
■ ¿No hay código duplicado? (Si repites lógica, extráela a un método)
■ ¿No hay números mágicos? (usa constantes)
■ ¿Las condiciones son legibles? (usa variables booleanas auxiliares si son muy largas)
■ ¿Los comentarios explican el PORQUÉ, no lo obvio?
■ ¿El código está formateado? (en IntelliJ: Ctrl + Alt + L)
■ ¿No hay warnings graves sin resolver?

Atajo de IntelliJ IDEA

Atajo ¿Para qué sirve?

Ctrl + Alt + L Formatear el código automáticamente

Ctrl + Alt + O Eliminar imports innecesarios

Ctrl + Z Deshacer el último cambio

Ctrl + / Comentar/descomentar una línea

Programación en Java — Tema 2 — DAW Pág. 22

 ■■ EJERCICIOS PRÁCTICOS

■ NIVEL BÁSICO

1 Declara una variable entera llamada edad con valor 20 y muéstrala por pantalla.

2 Declara una constante PI con valor 3.14159 y muéstrala.

3 Pide al usuario su nombre con Scanner y salúdalo: "Hola, [nombre]!"

4 Muestra los números del 1 al 10 usando un bucle for.

5 Dado un número, muestra si es par o impar usando el operador %.

6 Crea un array de 5 notas, inicialízalo con valores y muéstralos todos con for-each.

7 Crea un String con tu nombre y muestra: su longitud, la primera letra, y el texto en mayúsculas.

■ NIVEL MEDIO

Pide una nota (0-10) con Scanner y clasifícala: Suspenso / Aprobado / Notable / Sobresaliente. Valida que
1 esté en rango.

2 Crea un menú con do-while que se repita hasta que el usuario elija 0 (Salir). Usa switch para cada opción.

Pide números al usuario con while hasta que introduzca un número positivo. Muestra cuántos intentos
3 necesitó.

4 Dado un array de enteros, ordénalo con [Link]() y muéstralo antes y después.

Pide una frase al usuario y muestra: cuántas letras tiene, si empieza por 'A', y la frase al revés usando un
5 bucle.

6 Simula un login con 3 intentos máximo. Si acierta → acceso concedido. Si falla 3 → cuenta bloqueada.

■ NIVEL AVANZADO

Crea un programa que pida 5 notas con Scanner, las guarde en un array, y calcule la media. Muestra la nota
1 más alta y más baja.

Pide una contraseña y valida que: tenga mínimo 8 caracteres, empiece por mayúscula, y contenga al menos
2 un número. Usa métodos de String.

Crea un array de 10 enteros con valores del 1 al 10. Copia solo los elementos pares a un nuevo array usando
3 [Link] o un bucle.

Programación en Java — Tema 2 — DAW Pág. 23

 Crea un programa que genere la tabla de multiplicar del 1 al 10 y la guarde en un array bidimensional
4 int[10][10]. Muéstrala formateada.

Implementa un contador de palabras: pide una frase al usuario, divídela por espacios y cuenta cuántas
5 palabras tiene.

■ REFERENCIA RÁPIDA — CHULETA JAVA

■ Variables ■■ Tipos primitivos
int edad = 20; byte / short / int / long → enteros
double precio = 9.99; float / double → decimales
boolean ok = true; char → un carácter
final int MAX = 100; // constante boolean → true / false
String nombre = "Ana";

■■ Operadores ■■ Scanner
+ - * / % → aritméticos Scanner t = new Scanner([Link]);
== != > < >= <= → comparación int n = [Link]();
&& || ! → lógicos double d = [Link]();
(cond) ? a : b → ternario String s = [Link]();
(int) x → casting // Limpiar buffer: [Link]();

■ Control de flujo ■ String — métodos

if (cond) { } else { } [Link]() → longitud
switch (x) { case 1: ... break; } [Link](i) → carácter en i
while (cond) { } [Link](a,b) → subcadena
do { } while (cond); [Link](s2) → comparar
for (int i=0; i<n; i++) { } [Link]() → mayúsculas
[Link](a,b) → reemplazar
[Link]() → quitar espacios

■ Arrays
int[] a = new int[5];
int[] a = {1, 2, 3};
a[0] → primer elemento
[Link] → tamaño
[Link](a) → ordenar
[Link](a) → mostrar
[Link](a, n) → copiar

Programación en Java — Tema 2 — DAW Pág. 24