Java Tema 1
Introducción a Java
Estructura general de un programa Java#
Un programa Java siempre tiene al menos una clase pública y un método main, que es el punto de entrada (por donde empieza el programa cuando lo ejecutamos).
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.
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. En Java (y en casi todos los lenguajes), los tipos de datos básicos (llamados técnicamente primitivos), son:
| 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 que se usan solo cuando queremos que se ocupe más o menos memoria:
| 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. Llevan 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";Observa que el símbolo
=en programación no se usa como igualdad, tal y como se hace en matemáticas, si no que se utiliza como operador de asignación para darle valores a variables. Esto será muy relevante más adelante.
Si añadimos final delante del tipo de variable al crearla, esto no será una variable, si no una constante (que es lo mismo, un dato guardado en memoria, pero del que no se puede modificar su valor después).
Conversió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ícito (automático): 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ícito (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"; float decimal = Float.parseFloat(texto2); // "3.14" → 3.14 (tipo float)
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 |
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 (++, --). Éstos modifican el valor de la variable (+1 o -1), pero dependiendo de si 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 valor a 6 y luego la 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 |
Nú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).
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ú |
Comentarios#
Los comentarios sirven para documentar el código y no afectan a la ejecución (se obvian al compilar). 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 */
Errores frecuentes#
Cuando algo falla, Java te avisa con un mensaje en inglés. Estos son los más habituales en este tema:
| 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 y la de antes: el ; suele faltar en la anterior |
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 | 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 |