Java
¿Qué es Java?
Java es un lenguaje de programación de alto nivel y orientado a objetos, creado en 1995 por Sun Microsystems. Su regla principal es escribir el código una sola vez y ejecutarlo en cualquier equipo que tenga una máquina virtual de Java ("write once, run anywhere").
Hola Mundo en Java
public class Main {
public static void main(String[] args) {
System.out.println("Hola Mundo!");
}
}
> Hola Mundo!Probarlo >>
Componentes del ecosistema
- JDK (Java Development Kit): kit completo para desarrolladores. Contiene herramientas de compilación (javac), empaquetado (jar) y depuración, además del JRE.
- JRE (Java Runtime Environment): entorno de ejecución necesario únicamente para correr aplicaciones Java. Contiene la JVM y las librerías estándar del sistema.
- JVM (Java Virtual Machine): máquina virtual encargada de ejecutar el bytecode. Incluye el compilador JIT (Just-In-Time), que traduce bytecode a código máquina en tiempo real, y el Garbage Collector, que libera la memoria de los objetos sin uso.
Tipos de datos para tener en cuenta
- Enteros: byte (8 bits), short (16 bits), int (32 bits), long (64 bits, requiere sufijo L).
- Decimales: float (32 bits, requiere sufijo f), double (64 bits, predeterminado).
- Carácter: char (16 bits, utiliza comillas simples ' ').
- Lógico: boolean (valores true o false).
- Cadenas de texto: String (comillas dobles "hola"). Es inmutable.
Variables
Una variable es un espacio en memoria con un nombre, donde guardamos un valor. En Java siempre indicamos el tipo antes del nombre, y con la palabra final creamos constantes que no pueden cambiar.
Declaración e inicialización
int edad = 26; // tipo nombreVariable = valor;
final int torta = 2; // Para definir constantes
var texto = "Hola"; // Infiere el tipo según el contexto
Podemos usar variables para definir otras variables. Esto es súper útil al momento de trabajar con valores constantes en bucles e iteraciones (véase más adelante). Por ejemplo, si tenemos una variable contadora pero queremos mostrar el resultado al final, podemos usar una variable llamada total que sume a la contadora:
Acumular en una variable
int total = 0;
total += suma; // equivale a total = total + suma
Tip: para comentar el código se usa // mensaje (una línea) o /* mensaje */ (varias líneas).
Operadores
En Java podemos usar operadores de diversas formas, lo que nos permite trabajar con valores muy distintos. Los aritméticos están relacionados con operaciones matemáticas, los de comparación devuelven true o false, y los lógicos combinan condiciones siguiendo la lógica proposicional.
Operadores aritméticos, de comparación y lógicos
int suma = 5 + 3; // Aritméticos: + - * / %
boolean mayor = edad >= 18; // Comparación: == != > < >= <=
boolean puede = mayor && activo; // Lógicos: && (y) || (o) ! (no)
Incremento y asignación compuesta
contador++; // suma 1
contador--; // resta 1
precio *= 2; // precio = precio * 2
Condicionales
Las condicionales nos permiten ejecutar un bloque de código solo si se cumple una condición. Usamos if, else if y else para elegir entre caminos, y switch cuando comparamos un mismo valor contra varias opciones.
Estructura if / else if / else
if (edad >= 18) {
System.out.println("Mayor de edad");
} else if (edad >= 13) {
System.out.println("Adolescente");
} else {
System.out.println("Niño");
}
switch
switch (dia) {
case 1 -> System.out.println("Lunes");
case 2 -> System.out.println("Martes");
default -> System.out.println("Otro día");
}
Bucles e iteraciones
Los bucles repiten un bloque de código mientras se cumpla una condición. Usamos for cuando sabemos cuántas vueltas dar, while cuando depende de algo que cambia durante la ejecución, y for-each para recorrer listas y arrays.
for, while y for-each
for (int i = 0; i < 5; i++) {
System.out.println(i);
}
while (contador < 10) {
contador++;
}
for (String nombre : nombres) {
System.out.println(nombre);
}
Tip: break sale del bucle y continue salta directo a la siguiente vuelta.
Métodos
Un método es un bloque de código con nombre que realiza una tarea. Puede recibir parámetros y devolver un valor con return, lo que nos permite reutilizar código en vez de repetirlo cada vez que lo necesitamos. Si no devuelve nada, su tipo de retorno es void.
Declarar y llamar un método
public static int sumar(int a, int b) {
return a + b;
}
static void saludar(String nombre) {
System.out.println("Hola " + nombre);
}
int resultado = sumar(4, 6); // resultado vale 10
saludar("Ana"); // Hola Ana
Introducción a la POO
La Programación Orientada a Objetos (POO) organiza el código en objetos que combinan datos (atributos) y comportamiento (métodos). Una clase es el molde y cada objeto es una instancia creada a partir de ese molde con la palabra new.
Encapsulamiento
Protege los datos del objeto y solo deja modificarlos por medio de sus métodos.
Herencia
Una clase hija reutiliza lo que ya tiene la clase padre y le agrega lo suyo.
Polimorfismo
Objetos distintos responden al mismo mensaje, cada uno a su manera.
Abstracción
Mostramos solo lo importante y escondemos los detalles internos.
Clase y objeto
public class Perro {
String nombre;
int edad;
void ladrar() {
System.out.println(nombre + " dice: ¡Guau!");
}
}
Perro firulais = new Perro();
firulais.nombre = "Firulais";
firulais.ladrar(); // Firulais dice: ¡Guau!
POO I: constructores y encapsulamiento
El constructor es un método especial que se ejecuta al crear el objeto y sirve para darle sus valores iniciales. Con el encapsulamiento marcamos los atributos como private y los exponemos con getters y setters, así controlamos cómo se leen y modifican.
Constructor, getter y validación
public class Cuenta {
private double saldo;
public Cuenta(double saldoInicial) {
this.saldo = saldoInicial;
}
public double getSaldo() {
return saldo;
}
public void depositar(double monto) {
if (monto > 0) saldo += monto;
}
}
Tip: this hace referencia al objeto actual y evita confundir el atributo con el parámetro.
POO II: herencia
La herencia permite crear una clase nueva a partir de otra usando extends. La clase hija reutiliza los atributos y métodos de la clase padre, puede agregar los suyos o sobrescribirlos con @Override. Con super llamamos al constructor o a los métodos del padre.
extends, super y @Override
public class Animal {
protected String nombre;
public Animal(String nombre) { this.nombre = nombre; }
public String sonido() { return "..."; }
}
public class Gato extends Animal {
public Gato(String nombre) { super(nombre); }
@Override
public String sonido() { return "Miau"; }
}
POO III: polimorfismo e interfaces
El polimorfismo permite tratar objetos de distintas clases a través de un tipo en común, y que cada uno responda a su manera. Las clases abstractas definen métodos sin implementar, y las interfaces declaran un contrato que varias clases pueden cumplir con implements.
Interfaz y polimorfismo
public interface Figura {
double area();
}
public class Circulo implements Figura {
private double radio;
public Circulo(double radio) { this.radio = radio; }
public double area() { return Math.PI * radio * radio; }
}
Figura f = new Circulo(2);
System.out.println(f.area()); // 12.566...
Arrays
Un array guarda varios valores del mismo tipo en una sola variable, con un tamaño fijo que se define al crearlo. Cada elemento se accede por su posición (índice), que empieza en 0, y con length obtenemos cuántos elementos tiene.
Crear y recorrer un array
int[] notas = {7, 9, 6, 10};
String[] dias = new String[7];
dias[0] = "Lunes";
System.out.println(notas[1]); // 9
System.out.println(notas.length); // 4
for (int i = 0; i < notas.length; i++) {
System.out.println(notas[i]);
}
Tip: acceder a un índice fuera de rango lanza ArrayIndexOutOfBoundsException.
Colecciones
Las colecciones son estructuras dinámicas: crecen o se achican según lo que necesitemos. Se importan desde java.util y las más usadas son estas tres:
ArrayList
Lista ordenada que acepta repetidos. Ideal para recorrer en orden.
HashSet
Conjunto sin elementos repetidos. No garantiza el orden.
HashMap
Pares clave-valor para buscar datos rápido por su clave.
ArrayList y HashMap
import java.util.*;
List<String> alumnos = new ArrayList<>();
alumnos.add("Ana");
alumnos.add("Leo");
alumnos.remove("Leo");
System.out.println(alumnos.size()); // 1
Map<String, Integer> edades = new HashMap<>();
edades.put("Ana", 17);
System.out.println(edades.get("Ana")); // 17
Expresiones
Una expresión es cualquier combinación de variables, operadores y llamadas a métodos que produce un valor. Java evalúa primero los paréntesis, después multiplicación y división, y por último suma y resta. También existen las expresiones lambda, que permiten escribir funciones cortas en una sola línea.
Expresiones, ternario y lambdas
int resultado = (2 + 3) * 4; // 20
boolean aprobado = nota >= 6 && asistencia > 75;
String estado = aprobado ? "Aprobado" : "Recursa"; // operador ternario
alumnos.forEach(a -> System.out.println(a));
alumnos.removeIf(a -> a.startsWith("Z"));
Excepciones
Una excepción es un error que ocurre mientras el programa se ejecuta, por ejemplo dividir por cero o leer un archivo que no existe. Con try-catch capturamos el error para que el programa no se detenga, y el bloque finally se ejecuta siempre. Con throw podemos lanzar nuestras propias excepciones.
try, catch y finally
try {
int resultado = 10 / divisor;
System.out.println(resultado);
} catch (ArithmeticException e) {
System.out.println("No se puede dividir por cero");
} finally {
System.out.println("Fin de la operación");
}
Lanzar una excepción
if (edad < 0) {
throw new IllegalArgumentException("La edad no puede ser negativa");
}