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");
}