Java — Guía Básica Completa

01 · Estructura de una clase Java

¿Qué es una clase?

Todo programa en Java se llama clase. Desde los programas más pequeños que escribimos cuando aprendemos, hasta los grandes sistemas bancarios — todo es una clase.

Una clase tiene una estructura definida con componentes obligatorios que veremos a continuación.

1. Paquete (package)

Organiza las clases en carpetas o directorios. Es la primera línea que debe aparecer en una clase Java. Las clases con funcionalidades similares se agrupan en un mismo paquete.

Solo se puede declarar un paquete por clase. Si no se define, el compilador crea uno llamado default package.

2. Clase (class)

Después del paquete se declara el nombre de la clase con la palabra reservada class. El nombre debe comenzar con mayúscula.

Todo el código de la clase vive dentro de sus llaves { }.

3. Sentencias

Es la unidad mínima de ejecución de un programa. Cada sentencia indica una instrucción concreta.

Regla clave: toda sentencia termina obligatoriamente con punto y coma ;

4. Bloques

Un bloque es un conjunto de sentencias agrupadas. Se delimitan con llaves de apertura y cierre { }.

Los bloques pueden estar anidados (un bloque dentro de otro).

5. Método

Un método define el comportamiento de la clase. Se recomienda que el nombre del método sea siempre un verbo (calcular, mostrar, obtener…).

Su estructura básica es: tipo_de_retorno nombreDelMetodo(parámetros) { ... }

Existe un método especial llamado main — es el punto de entrada del programa. Java siempre empieza a ejecutar desde aquí. Se define exactamente así:

public static void main(String[] args) { // aquí comienza la ejecución del programa }

6. Comentarios

Los comentarios no se ejecutan — sirven para explicar el código. Java tiene tres tipos:

// Comentario de una sola línea /* Comentario multilínea puede ocupar varias líneas */ /** Comentario de documentación (Javadoc) * Se usa para generar documentación oficial del código */

Ejemplo completo — estructura básica

Aquí puedes ver todos los componentes juntos en un programa real:

package ejemplos; // 1. Paquete // 2. Comentario — a continuación la clase class Ejemplo1 { // 3. Clase public static void main(String[] args) { // 4. Método main System.out.println("Hola Mundo"); // 5. Sentencias System.out.println("Esto es un ejemplo"); } // fin del bloque main } // fin de la clase

02 · Identificadores

¿Qué es un identificador?

Los identificadores son los nombres únicos que el programador asigna a los componentes del programa: clases, métodos, variables, constantes, etc.

Elegir buenos nombres es fundamental para que el código sea legible y mantenible.

Reglas generales para nombrar

✦Nombres significativos: usa nombres que describan qué almacena o hace. Ej: RecetaBizcocho en lugar de Clase1.

✦Clases → PascalCase: cada palabra empieza con mayúscula. Ej: MiClase, RecetaBizcocho, CuentaBancaria.

✦Variables y métodos → camelCase: primera palabra en minúscula, el resto con mayúscula inicial. Ej: calcularTotal, nombreUsuario.

✦Constantes → MAYÚSCULAS_CON_GUIÓN: todo en mayúsculas, palabras separadas por _. Ej: TIEMPO_HORNEADO, MAX_INTENTOS.

✦Empieza por letra: puede contener números después, pero nunca al inicio. Ej: dato1 ✓ — 1dato ✗

✕Sin caracteres especiales: no se permiten espacios, +, %, *, @, #, etc.

✕Case-sensitive: Java diferencia mayúsculas de minúsculas. bizcocho, Bizcocho y BIZCOCHO son tres identificadores distintos.

✕No puedes usar palabras reservadas como nombre de tus variables o clases. Ej: no puedes llamar a una variable class o int.

03 · Palabras clave (palabras reservadas)

¿Qué son?

Son palabras que Java ha reservado para un propósito específico dentro del lenguaje. No puedes usarlas como nombres de tus clases, variables o métodos porque el compilador ya las usa para otra cosa.

Tipos de datos

Palabra	Descripción
int	Número entero de 32 bits. Rango: -2.147.483.648 a 2.147.483.647. Ej: `int edad = 25;`
long	Número entero de 64 bits, para valores muy grandes. Requiere `L` al final. Ej: `long poblacion = 8000000000L;`
short	Número entero de 16 bits. Rango: -32.768 a 32.767.
byte	Número entero de 8 bits. Rango: -128 a 127. Útil para ahorrar memoria.
double	Número decimal de 64 bits (alta precisión). Ej: `double precio = 9.99;`
float	Número decimal de 32 bits (menor precisión). Requiere `f` al final. Ej: `float altura = 1.75f;`
boolean	Solo puede ser `true` (verdadero) o `false` (falso). Ej: `boolean activo = true;`
char	Un único carácter Unicode de 16 bits. Usa comilla simple. Ej: `char letra = 'A';`

Estructuras de control — Condicionales

Palabra	Descripción
if	Ejecuta un bloque de código solo si se cumple una condición. Se puede combinar con `else if` para múltiples condiciones.
else	Indica qué hacer cuando la condición del `if` (o `else if`) NO se cumple.
switch	Permite evaluar una variable contra múltiples valores posibles de forma ordenada.
case	Cada opción posible dentro de un `switch`.
default	El caso que se ejecuta si ningún `case` coincide. Es opcional pero recomendable.

Estructuras de control — Bucles

Palabra	Descripción
for	Repite un bloque un número determinado de veces. Se usa cuando ya sabes cuántas repeticiones necesitas.
while	Repite mientras una condición sea verdadera. La condición se evalúa al principio — si es falsa desde el inicio, no se ejecuta ni una vez.
do	Se usa con `while`. La condición se evalúa al final — garantiza que el bloque se ejecuta al menos una vez.

Estructuras de control — Salto y retorno

Palabra	Descripción
break	Interrumpe y sale inmediatamente de un bucle o de un `switch`.
continue	Salta el resto de la iteración actual del bucle y pasa a la siguiente. No sale del bucle.
return	Sale del método actual. Puede devolver un valor si el método tiene tipo de retorno distinto de `void`.

Modificadores

Palabra	Descripción
public	El elemento es accesible desde cualquier clase del proyecto.
private	El elemento es accesible únicamente desde la clase donde se definió.
protected	Accesible desde la misma clase, sus subclases y otras clases del mismo paquete.
static	El elemento pertenece a la clase (no a un objeto). Se puede usar sin crear una instancia.
final	Una variable `final` no puede cambiar su valor. Un método `final` no puede sobreescribirse. Una clase `final` no puede heredarse.
abstract	Define clases o métodos que no tienen implementación completa — deben completarse en subclases.
synchronized	Indica que un método o bloque es atómico (seguro para múltiples hilos simultáneos).
volatile	Garantiza que el valor de un atributo compartido entre varios hilos esté siempre sincronizado.
transient	Especifica que un atributo no debe persistirse (guardarse) durante la serialización de un objeto.
native	Indica que el método está implementado en otro lenguaje dependiente de la plataforma (C, C++).

Estructura de datos

Palabra	Descripción
class	Define una clase. Es el bloque fundamental de Java.
interface	Declara una interfaz — un contrato que una clase debe cumplir.
extends	Indica la clase padre de una clase (herencia). Una clase solo puede extender a una clase.
implements	Indica qué interfaz(es) implementa una clase. Una clase puede implementar varias interfaces.
import	Importa una clase de otro paquete para poder usarla. Ej: `import java.util.Scanner;`
package	Agrupa un conjunto de clases e interfaces en un directorio lógico.

Otros

Palabra	Descripción
new	Crea una nueva instancia (objeto) de una clase. Ej: `Scanner sc = new Scanner(System.in);`
this	Referencia al objeto actual de la clase. También permite invocar al constructor de la misma clase.
super	Invoca a un método o constructor de la clase padre (superclase).
instanceof	Permite verificar si un objeto es instancia de una clase concreta. Devuelve `true` o `false`.
void	Indica que un método no devuelve ningún valor.
enum	Define un tipo de dato enumerado — un conjunto fijo de constantes con nombre.
assert	Afirma que una condición es verdadera. Si no lo es, lanza un error (útil para pruebas).
strictfp	Obliga a usar cálculos en coma flotante estrictos según el estándar IEEE 754.
const / goto	Palabras reservadas pero ya no se usan en Java moderno. Existen para compatibilidad histórica.

Excepciones

Palabra	Descripción
try	Marca el bloque de código donde puede ocurrir un error (excepción).
catch	Captura y maneja la excepción que ocurrió dentro del bloque `try`.
finally	Bloque que siempre se ejecuta, haya o no haya excepción. Ideal para liberar recursos.
throw	Lanza manualmente una excepción desde el código.
throws	Declara en la firma del método qué excepciones puede lanzar, para que el que lo llame las maneje.

04 · Variables y constantes

Variable

Un espacio reservado en memoria cuyo contenido puede cambiar durante la ejecución del programa. Ej: la edad de un usuario, el precio de un producto.

Constante

Un espacio reservado en memoria cuyo valor no cambia nunca durante toda la ejecución. Ej: el número de ruedas de un coche, el valor de PI.

Paso 1 — Declarar una variable

Declarar es dar un tipo y un nombre a la variable. Hay que declararla antes de usarla. El tipo determina qué clase de valores puede almacenar.

// Sintaxis: tipo nombreVariable; int edad; String nombre; boolean activo;

Paso 2 — Inicializar (primer valor)

Inicializar es dar un valor por primera vez a la variable, usando el operador =. Si no la inicializas, Java lo hace automáticamente (los números se inicializan en 0, los booleanos en false).

int edad = 0; // Java lo haría automáticamente String nombre = ""; // cadena vacía boolean activo = false;

Paso 3 — Asignar (cambiar el valor)

Asignar es dar un nuevo valor a una variable ya declarada. Según el tipo de dato, la sintaxis cambia:

// Numéricos: directamente int edad = 20; double precio = 9.99; float altura = 1.75f; // necesita 'f' al final long pob = 8000000000L; // necesita 'L' al final // Caracteres: comilla SIMPLE char genero = 'M'; // Cadenas de texto: comilla DOBLE String nombre = "Roberto García"; // Booleanos: solo true o false boolean casado = true;

Ámbito de una variable

El ámbito define dónde existe y puede usarse una variable. Fuera de su ámbito, la variable no existe. Hay tres tipos:

Local

Existe solo dentro del bloque donde fue declarada (un método, un bucle, un condicional). Cuando el bloque termina, la variable desaparece. Es el ámbito más reducido y recomendado siempre que sea posible.

De instancia (global)

Pertenece a cada objeto concreto de la clase. Todos los métodos de esa instancia pueden leerla y modificarla. Cada objeto tiene su propia copia.

Estática (de clase)

Pertenece a la clase, no a un objeto concreto. Se declara con static. Es compartida por todas las instancias — si un objeto la cambia, todos lo ven.

public class ClaseAmbitos { static int numero; // estática: pertenece a la clase String nombre; // instancia: cada objeto tiene la suya void calcular() { float precio; // local: solo existe en este método if (precio >= 10.95) { boolean verdad; // local: solo existe en este if } } }

Buena práctica: define las variables en el ámbito más reducido posible. Si solo necesitas una variable dentro de un método, no la declares como global. Esto hace el código más seguro y fácil de entender.

Declaración de constantes

Las constantes se definen a nivel de clase (global) usando dos palabras reservadas juntas: static y final. El nombre siempre va en MAYÚSCULAS. Una vez asignado su valor, no puede cambiarse.

// static final tipo NOMBRE_CONSTANTE = valor; static final int NUMERO_RUEDAS = 4; static final double IVA = 0.19; static final double PI = 3.14159; static final String PAIS_ORIGEN = "Chile"; static final int MAX_INTENTOS = 3;

05 · Estructuras de control

Condicional if / else if / else

Ejecuta bloques de código dependiendo de si una condición es verdadera o falsa. Se pueden encadenar con else if para evaluar varias condiciones en orden.

int nota = 75; if (nota >= 90) { System.out.println("Excelente"); // si nota >= 90 } else if (nota >= 60) { System.out.println("Aprobado"); // ← se ejecuta este } else { System.out.println("Reprobado"); // si ninguno se cumple }

Condicional switch

Ideal cuando quieres comparar una variable contra varios valores fijos. Es más limpio que varios else if cuando hay muchas opciones. El break evita que siga ejecutando los siguientes casos.

int dia = 3; switch (dia) { case 1: System.out.println("Lunes"); break; case 2: System.out.println("Martes"); break; case 3: System.out.println("Miércoles"); break; // ← este case 4: System.out.println("Jueves"); break; case 5: System.out.println("Viernes"); break; default: System.out.println("Fin de semana"); }

Bucle for

Se usa cuando sabes exactamente cuántas veces quieres repetir algo. Tiene tres partes: inicialización, condición e incremento.

// for (inicio; condición; incremento) for (int i = 0; i < 5; i++) { System.out.println("Vuelta número: " + i); // 0, 1, 2, 3, 4 } // for-each: para recorrer arrays o listas de forma simple String[] frutas = { "manzana", "pera", "uva" }; for (String f : frutas) { System.out.println(f); // manzana, pera, uva }

Bucle while

Repite el bloque mientras la condición sea verdadera. La condición se evalúa antes de ejecutar el bloque — si es falsa desde el inicio, no se ejecuta nunca.

int contador = 1; while (contador <= 5) { System.out.println("Contando: " + contador); contador++; // importante: evitar bucle infinito } // Imprime: 1, 2, 3, 4, 5

Bucle do-while

Similar al while, pero la condición se evalúa después de ejecutar el bloque. Esto garantiza que el código se ejecuta al menos una vez, aunque la condición sea falsa desde el principio.

int numero = 10; do { System.out.println("Se ejecuta al menos una vez"); numero++; } while (numero < 5); // condición falsa, pero ya se ejecutó

06 · Modificadores de acceso

¿Para qué sirven?

Los modificadores de acceso controlan quién puede ver y usar los elementos de una clase. Son fundamentales en la programación orientada a objetos para proteger los datos.

public

Accesible desde cualquier clase del proyecto, sin importar el paquete donde esté.

private

Solo accesible dentro de la misma clase donde se definió. El más restrictivo.

protected

Accesible en la clase, en sus subclases (herencia) y otras clases del mismo paquete.

static

No necesita crear un objeto para usarlo. Pertenece a la clase, no a la instancia.

public class CuentaBancaria { private double saldo; // solo esta clase puede verlo protected String titular; // clase + subclases + paquete public String banco; // cualquiera puede verlo static int totalCuentas; // compartido por todas las instancias public double getSaldo() { // método público para acceder al saldo return saldo; } }

07 · Manejo de excepciones

¿Qué es una excepción?

Una excepción es un error que ocurre durante la ejecución del programa (no en la compilación). Por ejemplo: dividir entre cero, intentar acceder a un archivo que no existe, o convertir texto inválido a número.

Si una excepción no se maneja, el programa se detiene abruptamente. Con try/catch podemos capturarla y manejarla de forma controlada.

try { // Bloque "peligroso" — código que podría fallar int resultado = 10 / 0; // división por cero! System.out.println("Resultado: " + resultado); } catch (ArithmeticException e) { // Se ejecuta si ocurre exactamente ese tipo de error System.out.println("Error matemático: " + e.getMessage()); } catch (Exception e) { // Captura cualquier otro tipo de excepción System.out.println("Error general: " + e.getMessage()); } finally { // Siempre se ejecuta, haya error o no System.out.println("Programa finalizado correctamente."); }

try { }

Envuelve el código que podría generar un error. Si ocurre, Java salta directamente al catch.

catch (Tipo e) { }

Captura y maneja el error. Puedes tener varios catch para distintos tipos de excepción.

finally { }

Siempre se ejecuta, sin importar si hubo error. Ideal para cerrar archivos, conexiones, etc.

throw / throws

throw lanza una excepción manualmente. throws avisa que un método puede lanzarla.

08 · Arrays

¿Qué es un array?

Un array es una lista de elementos del mismo tipo almacenados en posiciones contiguas de memoria. Todos los elementos deben ser del mismo tipo (todos enteros, todos Strings, etc.).

El tamaño del array se define al crearlo y no puede cambiarse después. Los índices siempre empiezan en 0, no en 1.

[0]

10

[1]

20

[2]

30

[3]

40

[4]

50

Array de 5 enteros — posición [2] resaltada contiene el valor 30

Declarar un array

Hay tres formas válidas de declarar un array — todas son equivalentes:

// Las tres formas son válidas int[] arrayEnteros; int arrayEnteros[]; int[] arrayEnteros[]; // Ejemplos por tipo int[] numeros; String[] nombres; char[] letras;

Inicializar un array

Hay dos formas de dar valores a un array:

// Opción 1: por tamaño (valores por defecto = 0 / null / false) int[] numeros = new int[5]; String[] nombres = new String[3]; // Opción 2: con valores directos int[] notas = { 70, 85, 90, 60, 95 }; String[] frutas = { "manzana", "pera", "uva" };

Recuperar y asignar valores

Para leer o escribir en una posición específica, usamos el índice entre corchetes [ ]:

int[] arrayEnteros = { 0, 0, 0, 0, 0 }; // Asignar: arrayEnteros[2] = 10 arrayEnteros[2] = 10; // posición 2 ahora vale 10 // Recuperar: leer el valor de una posición int numero = arrayEnteros[2]; // numero = 10 // Cambiar otro elemento String[] arrayNombres = { "Pedro", "Juan", "María" }; arrayNombres[0] = "Sergio"; // "Pedro" → "Sergio"

Recorrer un array con bucles

La propiedad .length devuelve el número de elementos del array:

int[] notas = { 70, 85, 90, 60, 95 }; // Con for clásico (tienes acceso al índice) for (int i = 0; i < notas.length; i++) { System.out.println("Nota " + i + ": " + notas[i]); } // Con for-each (más simple, pero sin índice) for (int nota : notas) { System.out.println(nota); // 70, 85, 90, 60, 95 }