Fundamentos de programación Tema 1
Variables y operadores
Funciona en el IDE online. Todo lo de esta sección funciona en el IDE online: pulsa Pruébalo en cualquier ejemplo, o abre el IDE y escribe el tuyo. Sin instalar nada.
Estructura general de un programa Java#
Un programa Java tiene siempre un método main, que es el punto de entrada: por donde empieza el programa cuando lo ejecutas. Hasta Java 24, además, ese main tiene que ir dentro de una clase.
public class MiPrograma {
public static void main(String[] args) {
// Aquí comienza la ejecución del programa
System.out.println("¡Hola, mundo!");
}
}void main() {
// Aquí comienza la ejecución del programa
IO.println("¡Hola, mundo!");
}En este código podemos ver:
public class MiPrograma: define una clase llamada MiPrograma. Por ahora, pensaremos en una clase como un fichero de Java, aunque más adelante veremos lo que son realmente.public static void main(String[] args): método principal, fragmento de código por el que se inicia el programa.
Importante
La clase pública se tiene que llamar igual que el fichero, con las mismas mayúsculas: public class MiPrograma va en MiPrograma.java. Si no coinciden, Java no compila. Por costumbre, los nombres de las clases empiezan por mayúscula y no llevan espacios ni tildes: CalculadoraNotas, no calculadora notas.
Nota
Desde Java 25 un programa sencillo puede escribirse más corto: sin public class, con void main() y mostrando texto con IO.println. Es lo que verás en las pestañas Java 25 de estos apuntes. La forma larga sigue funcionando en Java 25; la corta no funciona en Java 21.
Variables y tipos#
Una variable es un espacio en memoria que se utiliza para guardar un dato. Los tipos de datos que más vas a usar en Java son estos (todos menos String son primitivos):
| Tipo | Qué guarda | Ejemplo | Memoria |
|---|---|---|---|
int | Números enteros, hasta unos ±2.000 millones | int edad = 18; | 4 bytes |
double | Números decimales (con punto, no con coma) | double altura = 1.75; | 8 bytes |
boolean | Un valor lógico: true o false | boolean mayor = true; | depende de Java |
char | Un solo carácter, entre comillas simples | char letra = 'A'; | 2 bytes |
String | Texto: palabras, frases, contraseñas…, entre comillas dobles | String nombre = "Ana"; | lo que ocupe el texto |
String técnicamente no es un tipo primitivo (es una clase), pero en principio lo usaremos como si lo fuese.
También existen otros tipos, para números más grandes (long) o para ahorrar memoria (byte, short, float):
| Tipo | Qué guarda | Ejemplo | Memoria |
|---|---|---|---|
byte | Enteros muy pequeños, de -128 a 127 | byte nivel = 3; | 1 byte |
short | Enteros pequeños, de -32.768 a 32.767 | short anio = 2026; | 2 bytes |
long | Enteros enormes. Si el número no cabe en un int, se le pone una L al final | long poblacion = 8100000000L; | 8 bytes |
float | Decimales con menos precisión. Llevan una f al final | float precio = 2.5f; | 4 bytes |
Ejemplo:
int edad = 18;
double altura = 1.75;
boolean mayor = true;
String nombre = "Ana";Nota
Observa que el símbolo = en programación no se usa como igualdad, como en matemáticas, sino como operador de asignación: guarda un valor en una variable. Esto será muy relevante más adelante.
Si añades final delante del tipo al crear una variable, ya no es una variable, sino una constante: un dato guardado en memoria cuyo valor no se puede cambiar después. Por costumbre, su nombre va en mayúsculas:
final double IVA = 0.21;
// IVA = 0.10; ← error: no se puede cambiar una constanteConversión de tipos (casting)#
A veces necesitamos cambiar un tipo de dato por otro. Existen varios tipos de conversiones, en función del tipo de dato original y el tipo de dato al que queremos convertirlo:
- Implícita (automática): hay veces (cuando no hay pérdida de información), que Java puede hacerlo automáticamente. Por ejemplo:
Java
int x = 5; double y = x; // Conversión implícita: int → double // Puede hacerlo porque no se pierde información (al revés sí, se perderían decimales)
- Explícita (casting): otras veces (cuando sí puede haber pérdida de información), debe ser el programador quien indique a qué tipo se desea convertir. Se usa la sintaxis
(tipoDeseado) variable. Por ejemplo:Javadouble a = 9.7; int b = (int) a; // Conversión explícita: double → int (pierde decimales, por eso debemos indicarlo nosotros)
- Conversión de String a números: Muy habitual cuando pedimos datos por consola. Para convertir textos (String) a valores numéricos usamos métodos algo más complejos, cuya explicación técnica veremos más adelante:
Java
String texto1 = "123"; int numero = Integer.parseInt(texto1); // "123" → 123 String texto2 = "3.14"; double decimal = Double.parseDouble(texto2); // "3.14" → 3.14
Resumen de las conversiones más habituales:
| De | A | ¿Cómo? | Ejemplo | Resultado |
|---|---|---|---|---|
int | double | Automático | double y = 5; | 5.0 |
double | int | Casting: pierde los decimales | (int) 9.7 | 9 |
char | int | Automático | 'a' + 1 | 98 |
int | char | Casting | (char) 100 | 'd' |
String | int | Método | Integer.parseInt("123") | 123 |
String | double | Método | Double.parseDouble("3.14") | 3.14 |
| número | String | Sumarle un texto | "" + 5 | "5" |
Operadores matemáticos#
Los operadores matemáticos permiten hacer operaciones con variables numéricas. En la tabla, cada fila empieza con int a = 7; e int b = 2;:
| Operador | Qué hace | Ejemplo | Resultado |
|---|---|---|---|
+ | Suma | a + b | 9 |
- | Resta | a - b | 5 |
* | Multiplicación | a * b | 14 |
/ | División. Entre enteros, se queda solo con la parte entera | a / b | 3 |
/ | División con decimales (si alguno es double) | 7.0 / 2 | 3.5 |
% | Resto de la división | a % b | 1 |
++ | Suma 1 a la variable | a++ | a pasa a valer 8 |
-- | Resta 1 a la variable | a-- | a pasa a valer 6 |
+= | Suma y guarda el resultado en la variable | a += b | a pasa a valer 9 |
-= | Resta y guarda el resultado en la variable | a -= b | a pasa a valer 5 |
*= | Multiplica y guarda el resultado en la variable | a *= b | a pasa a valer 14 |
/= | Divide y guarda el resultado en la variable | a /= b | a pasa a valer 3 |
%= | Guarda en la variable el resto de dividirla | a %= b | a pasa a valer 1 |
Ejemplo:
int a = 7;
int b = 2;
System.out.println(a + b); // 9
System.out.println(a / b); // 3 (solo muestra parte entera porque estamos dividiendo números enteros, por lo que entiende Java que el resultado deberá ser entero)
System.out.println(a % b); // 1 (resto)Cuidado con los incrementos y decrementos (++, --). Estos modifican el valor de la variable (+1 o -1), pero dependiendo de si se ponen antes de la variable (pre-incremento o pre-decremento) o después (post-incremento o post-decremento), la incrementan antes o después de usarla.
Veámoslo más claro en un ejemplo:
int a = 5;
System.out.println(++a); // Cambia el valor a 6 y luego lo imprime (imprime, por lo tanto, 6).int a = 5;
System.out.println(a++); // Imprime, y después cambia el valor (imprime, por lo tanto, 5).Si a empieza valiendo 5:
| Código | Qué imprime | Cuánto vale a después |
|---|---|---|
System.out.println(++a); | 6 | 6 |
System.out.println(a++); | 5 | 6 |
System.out.println(--a); | 4 | 4 |
System.out.println(a--); | 5 | 4 |
La división entre enteros#
Si los dos números de una división son enteros, Java hace una división entera: se queda con la parte entera y tira los decimales, sin redondear. Es una de las sorpresas más frecuentes al calcular una media:
int nota1 = 7;
int nota2 = 8;
double media = (nota1 + nota2) / 2;
System.out.println(media); // 7.0, ¡no 7.5!Guardar el resultado en un double no basta: cuando llega a la variable, la división ya se ha hecho entre enteros. Para que tenga decimales, al menos uno de los dos números tiene que ser decimal antes de dividir:
int nota1 = 7;
int nota2 = 8;
System.out.println((nota1 + nota2) / 2.0); // 7.5: 2.0 es un decimal
System.out.println((double) (nota1 + nota2) / 2); // 7.5: el casting convierte la suma antes de dividirJuntar textos y números con +#
Con textos, + no suma: junta (se dice concatenar). Si a un lado hay un texto, lo del otro lado se convierte en texto y se pega:
int edad = 18;
System.out.println("Tengo " + edad + " años"); // Tengo 18 añosJava lee los + de izquierda a derecha, y eso tiene una trampa: en cuanto aparece un texto, todo lo que va detrás se junta en lugar de sumarse.
System.out.println("Total: " + 2 + 3); // Total: 23
System.out.println("Total: " + (2 + 3)); // Total: 5: el paréntesis se calcula primero
System.out.println(2 + 3 + " en total"); // 5 en total: la suma va antes que el textoNúmeros aleatorios#
Para juegos, sorteos o retos de consola, a menudo necesitamos un número al azar. Math.random() devuelve un double aleatorio entre 0 (incluido) y 1 (sin incluir), por ejemplo 0.7314.... Para convertirlo en un número entero de un rango, se multiplica, se pasa a int y se le suma el primero del rango:
int dado = (int) (Math.random() * 6) + 1; // de 1 a 6| Quiero un número… | Código | Puede salir |
|---|---|---|
| De 0 a 9 | (int) (Math.random() * 10) | 0, 1, 2… 9 |
| De 1 a 10 | (int) (Math.random() * 10) + 1 | 1, 2, 3… 10 |
| De 1 a 6 (un dado) | (int) (Math.random() * 6) + 1 | 1, 2, 3, 4, 5, 6 |
| De 50 a 100 | (int) (Math.random() * 51) + 50 | 50, 51… 100 |
La regla: (int) (Math.random() * cuántos) + primero, donde cuántos es la cantidad de números posibles (de 50 a 100 hay 51).
Atención
Los paréntesis importan. (int) Math.random() * 6 convierte a int solo Math.random(), que siempre es menor que 1 y se queda en 0: el resultado es siempre 0. El casting tiene que abarcar la multiplicación entera: (int) (Math.random() * 6).
Entrada y salida por consola#
Para que nuestros programas puedan interactuar con el usuario, deben mostrar y pedir información por consola.
- Salida de datos: mostrar información al usuario.
System.out.println("¡Hola, mundo!");IO.println("¡Hola, mundo!");
- Entrada de datos: leer información que escribe el usuario. En Java 21 se usa un
Scanner, que se crea una sola vez al principio delmain. En Java 25 basta conIO.readln.import java.util.Scanner; // arriba del todo, antes de la clase Scanner sc = new Scanner(System.in); // una sola vez, al principio del main System.out.print("¿Cómo te llamas? "); String nombre = sc.nextLine(); // Otra opción, sin Scanner. Es más corta, pero no funciona en todas las consolas // (en algunas de VS Code devuelve null): // String nombre = System.console().readLine("¿Cómo te llamas? ");String nombre = IO.readln("¿Cómo te llamas? ");
Cuidado
Todo lo que el usuario introduce en un teclado, Java lo considera un String. Si lo que estás pidiendo al usuario es un número, debes convertirlo:
System.out.print("¿Qué edad tienes? ");
int edad = Integer.parseInt( sc.nextLine() );
// Con System.console():
// int edad = Integer.parseInt( System.console().readLine("¿Qué edad tienes? ") );int edad = Integer.parseInt( IO.readln("¿Qué edad tienes? ") );Para mostrar datos hay dos instrucciones muy parecidas:
| Instrucción | Qué hace | Si escribes "Hola" y luego "Ana", se ve… |
|---|---|---|
System.out.println | Escribe y salta a la línea siguiente | Hola y, debajo, Ana |
System.out.print | Escribe y se queda en la misma línea | HolaAna, todo junto: el espacio lo tienes que poner tú |
Dar formato a la salida: printf#
Con + se junta todo, pero no se decide cómo sale cada dato: cuántos decimales lleva un precio, o que los números queden alineados en columna. Para eso está System.out.printf: se escribe el texto con huecos, y detrás, los datos que van en cada hueco, en el mismo orden:
String nombre = "Ana";
int edad = 17;
double nota = 8.4567;
System.out.printf("%s tiene %d años y un %.2f de nota%n", nombre, edad, nota);Sale Ana tiene 17 años y un 8,46 de nota. Cada hueco empieza por % y su letra dice qué va dentro:
| Hueco | Para | Ejemplo | Sale |
|---|---|---|---|
%d | Un entero (int, long) | printf("%d", 42) | 42 |
%f | Un decimal (double, float). Con .2, dos decimales | printf("%.2f", 3.14159) | 3,14 |
%s | Un texto, o cualquier otra cosa escrita como texto | printf("%s", "Ana") | Ana |
%c | Un carácter | printf("%c", 'A') | A |
%b | Un boolean | printf("%b", true) | true |
%n | Un salto de línea: printf no salta solo, como print |
Entre el % y la letra se puede decir cuánto ocupa el dato, para hacer columnas: %5d rellena con espacios por la izquierda hasta 5 caracteres, %-10s por la derecha (el texto queda pegado a la izquierda) y %05d con ceros.
System.out.printf("%-8s%6s%n", "Fruta", "Precio");
System.out.printf("%-8s%6.2f%n", "Pera", 1.5);
System.out.printf("%-8s%6.2f%n", "Melón", 12.25);Fruta Precio
Pera 1,50
Melón 12,25Nota
El decimal sale con coma porque printf escribe los números como se escriben en el idioma del ordenador, y en español es la coma (println siempre pone el punto). Los miles, igual: con %,d, 1234567 sale 1.234.567.
Si en vez de escribirlo lo quieres guardar, String.format hace lo mismo y devuelve el texto. Vale también en Java 25, que no tiene printf en IO:
double total = 1234.5;
String linea = String.format("Total: %.2f €", total);
System.out.println(linea); // Total: 1234,50 €Comentarios#
Los comentarios sirven para documentar el código y no afectan a la ejecución: el compilador los ignora. En Java, se pueden crear comentarios:
- De una línea:
Java
// Esto es un comentario de una línea - De varias líneas:
Java
/* Esto es un comentario que ocupa varias líneas */ - De documentación, o Javadoc: empiezan por
/**y van justo encima de una clase o de un método, para decir qué hace. Los IDE los enseñan al pasar el ratón por encima, y con ellos se genera la documentación del programa. Los verás con los métodos, en Funciones y métodos.Java/** Calcula el precio con el IVA incluido. */
Errores frecuentes#
Cuando algo falla, Java te avisa con un mensaje en inglés. Estos son los más habituales en este tema. Son los mensajes de javac; VS Code, al subrayar en rojo, a veces los dice con otras palabras:
| Mensaje | Qué significa | Cómo se arregla |
|---|---|---|
';' expected | Falta un punto y coma al final de una instrucción | Mira la línea que indica el error: el ; falta al final de esa línea, donde marca el ^ |
cannot find symbol | Usas algo que Java no conoce: una variable sin crear, o un nombre mal escrito | Revisa mayúsculas y minúsculas: String, no string; edad y Edad son variables distintas |
incompatible types: possible lossy conversion from double to int | Intentas guardar un decimal en un int y se perderían los decimales | Usa double, o haz el casting tú: (int) 9.7 |
incompatible types: int cannot be converted to String | El tipo del valor no es el de la variable | Pon el valor del tipo correcto: String s = "5"; |
variable x might not have been initialized | Usas una variable a la que nunca le has dado valor | Dale un valor al crearla: int x = 0; |
NumberFormatException: For input string: "hola" | Al ejecutar: parseInt ha recibido algo que no es un número | El usuario ha escrito letras donde se esperaba un número. Por ahora, escribe un número; más adelante verás cómo se controlan los errores con las excepciones |
ArithmeticException: / by zero | Al ejecutar: has dividido un int entre cero (con double no hay error: 5.0 / 0 da Infinity) | Comprueba antes con un if que el divisor no es 0 |
cannot find symbol en Scanner | Falta la línea del import | Añade import java.util.Scanner; arriba del todo |
class MiPrograma is public, should be declared in a file named MiPrograma.java | El nombre de la clase pública y el del fichero no coinciden | Cambia uno de los dos para que sean iguales, mayúsculas incluidas |
Una media sale sin decimales: 7.0 en vez de 7.5 | Has dividido dos enteros: la división entera tira los decimales | Haz decimal uno de los dos antes de dividir: / 2.0 o (double) suma / n |
Sale Total: 23 en vez de Total: 5 | Después de un texto, + junta en lugar de sumar | Pon la suma entre paréntesis: "Total: " + (2 + 3) |
IllegalFormatConversionException: d != java.lang.Double | Al ejecutar: en un printf, un hueco %d (de enteros) ha recibido un decimal | Usa %f para los double (%.2f con dos decimales), y %d para los int |
MissingFormatArgumentException: Format specifier '%s' | Al ejecutar: el printf tiene más huecos % que datos | Pon detrás un dato por cada hueco, en el mismo orden |
Todo sale en la misma línea con printf | printf no salta de línea solo | Termina el formato con %n: printf("%d%n", x) |