Fundamentos de Java · Manual visual

TiposDeDatos.java

01 · Capítulo uno

Tipos de datos

Todo dato en Java pertenece a un tipo. El tipo le dice al programa cuánta memoria reservar y qué operaciones puedes hacer con él. En Java hay dos grandes familias: tipos primitivos (los básicos del lenguaje) y tipos de referencia (objetos como String, arreglos y clases).

Los imprescindibles

Los 3 tipos que usarás todos los días

De todos los tipos que existen, hay tres que aparecen en prácticamente cualquier programa: int para enteros, String para texto y boolean para decisiones lógicas.

Cadete.java

// Los 3 tipos más usados de Java
int edad = 20;
String nombre = "Lua";
boolean esCadete = true;

System.out.println(nombre + " tiene " + edad + " años");
System.out.println("¿Es cadete? " + esCadete);

Catálogo completo

Los 8 tipos primitivos de Java

Java tiene exactamente ocho tipos primitivos. Cuatro son para números enteros, dos para decimales, uno para caracteres y uno para valores lógicos.

Primitivos.java

// Enteros (4 tipos, según el rango)
byte  nivelBateria = 95;          // -128 a 127
short anioMision   = 2026;        // pequeño
int   distancia    = 1500000;     // el más usado
long  poblacion    = 8100000000L; // muy grande, lleva 'L'

// Decimales (2 tipos, según la precisión)
float  temperatura = 36.5f;       // precisión simple, lleva 'f'
double precisionGPS = 0.000012345; // precisión doble (la habitual)

// Caracteres y booleanos
char    inicial  = 'L';           // un solo carácter, comillas simples
boolean activo   = true;          // solo true o false

Más allá de los primitivos

Tipos de referencia

Todo lo que no es primitivo es un tipo de referencia: no guarda el valor directamente sino una "dirección" a un objeto. Los más comunes son String, los arreglos y las clases que tú o Java definen.

Referencias.java

// String: una secuencia de caracteres
String mensaje = "Hola, mundo";

// Arreglo: una colección ordenada de valores del mismo tipo
int[] notas = {85, 92, 78, 100};
String[] cadetes = {"Lua", "Max", "Iris"};

// Objeto de una clase (definida por ti o por Java)
Scanner entrada = new Scanner(System.in);

System.out.println("Primera nota: " + notas[0]);
System.out.println("Total de cadetes: " + cadetes.length);

Variables.java

02 · Capítulo dos

Variables

Una variable es un contenedor con nombre que guarda un valor. En Java existen cuatro clases de variables, y la diferencia entre ellas es dónde se declaran y cuánto tiempo viven.

Resumen

Las cuatro clases de variables

Locales · viven dentro de un método. Solo existen mientras el método se ejecuta.
De instancia · pertenecen a un objeto. Cada objeto tiene su propia copia.
Estáticas (de clase) · pertenecen a la clase entera. Hay una sola copia compartida.
Parámetros · variables que recibe un método cuando lo invocas.

Ejemplo completo

Las cuatro en una sola clase

Este ejemplo muestra las cuatro clases conviviendo dentro de la misma clase Cadete. Lee los comentarios para identificar cada una.

Cadete.java

public class Cadete {

    // Variable de instancia
    // Cada Cadete tiene su propio nombre
    String nombre;

    // Variable estática (de clase)
    // Compartida por TODOS los cadetes
    static String academia = "Academia Estelar";

    // 'nombre' y 'edadInicial' son parámetros
    public Cadete(String nombre, int edadInicial) {
        this.nombre = nombre;

        // Variable local: solo existe dentro de este método
        int anioIngreso = 2026 - edadInicial;
        System.out.println(nombre + " ingresó en " + anioIngreso);
    }

    public static void main(String[] args) {
        Cadete lua = new Cadete("Lua", 20);
        Cadete max = new Cadete("Max", 22);
        System.out.println("Academia: " + Cadete.academia);
    }
}

Control.java

03 · Capítulo tres

Sentencias de control

Las sentencias de control deciden el rumbo del programa. Se dividen en tres grupos: condicionales (eligen entre opciones), bucles (repiten acciones) y sentencias de salto (cambian el flujo dentro de un bucle).

Grupo 1 — Condicionales

if, if-else, if-else if-else y switch

Las condicionales ejecutan código solo si se cumple una condición. Cuando son pocas opciones se usa if, y cuando son muchas y específicas conviene un switch.

Condicionales.java

int edad = 20;

// if simple
if (edad >= 18) {
    System.out.println("Acceso permitido");
}

// if-else
if (edad >= 18) {
    System.out.println("Cadete autorizado");
} else {
    System.out.println("Demasiado joven");
}

// if-else if-else (varias opciones)
if (edad < 18) {
    System.out.println("Pre-cadete");
} else if (edad < 25) {
    System.out.println("Cadete");
} else {
    System.out.println("Oficial");
}

// switch (cuando comparas contra valores fijos)
String dia = "LUNES";
switch (dia) {
    case "LUNES":     System.out.println("Entrenamiento"); break;
    case "MARTES":    System.out.println("Clase de Java"); break;
    case "MIERCOLES": System.out.println("Simulador");     break;
    default:          System.out.println("Día libre");
}

Grupo 2 — Bucles

for, while, do-while y for-each

Los bucles repiten instrucciones. Usa for cuando sabes cuántas veces, while cuando depende de una condición, do-while cuando quieres ejecutar al menos una vez, y for-each para recorrer colecciones.

Bucles.java

// for: cuenta regresiva de despegue (sabemos cuántas iteraciones)
for (int i = 5; i >= 1; i--) {
    System.out.println("Despegue en: " + i);
}

// while: pedir contraseña hasta acertar (condición al inicio)
int intentos = 0;
while (intentos < 3) {
    System.out.println("Ingrese contraseña...");
    intentos++;
}

// do-while: mostrar menú al menos una vez (condición al final)
int opcion;
do {
    System.out.println("1. Volar  2. Salir");
    opcion = 2; // simulación
} while (opcion != 2);

// for-each: recorrer una colección
String[] cadetes = {"Lua", "Max", "Iris"};
for (String c : cadetes) {
    System.out.println("Cadete a bordo: " + c);
}

Grupo 3 — Saltos

break, continue y return

Las sentencias de salto modifican el flujo dentro de un bucle o método: break sale del bucle, continue salta a la siguiente iteración y return termina el método.

Saltos.java

// Imprimir números impares del 1 al 10, pero parar en el 7
for (int i = 1; i <= 10; i++) {
    if (i == 7) {
        break;          // termina el bucle aquí
    }
    if (i % 2 == 0) {
        continue;       // salta este número y va al siguiente
    }
    System.out.println(i);   // 1, 3, 5
}

// return: termina el método y devuelve un valor (si tiene tipo)
public static boolean esMayorDeEdad(int edad) {
    if (edad < 18) {
        return false;
    }
    return true;
}

Metodos.java

04 · Capítulo cuatro

Métodos

En Java, las funciones se llaman métodos. Un método es un bloque de código con nombre que ejecuta una tarea. Pueden clasificarse por su retorno, sus parámetros, su pertenencia a una clase o un objeto, y algunos casos especiales como recursivos y sobrecargados.

Anatomía

Las partes de un método

Antes de clasificarlos, observa la estructura básica. Todo método tiene un modificador, un tipo de retorno, un nombre, una lista de parámetros y un cuerpo.

Anatomia.java

// modificador  retorno  nombre   parámetros
   public       int      sumar    (int a, int b) {
       return a + b;   // cuerpo: lo que el método hace
   }

Por retorno y parámetros

Cuatro combinaciones básicas

Un método puede devolver un valor o no (void), y puede recibir parámetros o no. Combinando esas dos opciones obtienes los cuatro casos básicos.

Combinaciones.java

// 1) Sin parámetros, sin retorno
public static void encenderMotores() {
    System.out.println("Motores encendidos");
}

// 2) Con parámetros, sin retorno
public static void saludar(String nombre) {
    System.out.println("Hola, " + nombre);
}

// 3) Sin parámetros, con retorno
public static int obtenerAnioActual() {
    return 2026;
}

// 4) Con parámetros y con retorno
public static int sumarCombustible(int actual, int agregar) {
    return actual + agregar;
}

Por pertenencia y origen

Estáticos, de instancia y predefinidos

Un método estático pertenece a la clase y se llama directamente. Uno de instancia necesita un objeto creado. Los predefinidos ya vienen en Java y no los escribes tú.

Pertenencia.java

public class Nave {

    // Método de instancia: necesita un objeto Nave
    public void despegar() {
        System.out.println("Esta nave despega");
    }

    // Método estático: se llama desde la clase
    public static void mostrarTipo() {
        System.out.println("Nave estelar clase X-7");
    }

    public static void main(String[] args) {
        // Estático: directo desde la clase
        Nave.mostrarTipo();

        // De instancia: necesita crear el objeto
        Nave miNave = new Nave();
        miNave.despegar();

        // Predefinido de Java
        double raiz = Math.sqrt(144);
        System.out.println("Raíz de 144 = " + raiz);
    }
}

Casos especiales

Recursivos y sobrecargados

Un método recursivo se llama a sí mismo y necesita una condición de parada. Un método está sobrecargado cuando existen varias versiones con el mismo nombre pero distintos parámetros.

Especiales.java

// Recursivo: factorial de un número
public static int factorial(int n) {
    if (n <= 1) {
        return 1;             // condición de parada
    }
    return n * factorial(n - 1); // se llama a sí mismo
}

// Sobrecarga: mismo nombre, distintos parámetros
public static int sumar(int a, int b) {
    return a + b;
}

public static double sumar(double a, double b) {
    return a + b;
}

public static int sumar(int a, int b, int c) {
    return a + b + c;
}

public static void main(String[] args) {
    System.out.println(factorial(5));      // 120
    System.out.println(sumar(2, 3));       // usa la versión int + int
    System.out.println(sumar(2.5, 3.1));   // usa la versión double + double
    System.out.println(sumar(1, 2, 3));    // usa la versión de 3 enteros
}

Aprende Javadesde lo esencial.