Nuestro primer programa

public class HolaMundo {
    public static void main(String[] args) {
        System.out.println("¡Hola Mundo!");
    }
}

Creando nuestro primer programa

1. Abrir IntelliJ IDEA
2. Crear un nuevo proyecto (File > New > Project)
3. Seleccionar Java y el JDK instalado
4. Nombrar el proyecto “PrimerPrograma”
5. Crear una nueva clase (Click derecho en src > New > Java Class)
6. Nombrar la clase “HolaMundo”
7. Escribir el código del Hola Mundo
8. Ejecutar (Botón verde de play o Shift+F10)

Sintaxis básica de Java

Las reglas fundamentales de Java incluyen:

1. Sensibilidad a mayúsculas y minúsculas (case-sensitive)
2. Nombres de clase comienzan con mayúscula (HolaMundo)
3. Nombres de métodos comienzan con minúscula (main)
4. Nombre del archivo debe coincidir con el nombre de la clase pública (HolaMundo.java)
5. Todas las instrucciones terminan con punto y coma (;)

Estructura de un programa Java

// 1. Declaraciones de paquete (opcional)
package com.ejemplo.miproyecto;

// 2. Declaraciones de importación (opcionales)
import java.util.Scanner;

// 3. Declaración de la clase
public class MiPrograma {
    // 4. Variables de clase (atributos)
    static int contador = 0;
    
    // 5. Métodos (incluyendo el main)
    public static void main(String[] args) {
        // 6. Cuerpo del método con variables locales
        int numero = 10;
        System.out.println("El número es: " + numero);
    }
    
    // 7. Otros métodos
    public static void otroMetodo() {
        // Código aquí
    }
}

Variables en Java

Una variable es un espacio de memoria con:

• Un nombre
• Un tipo de dato
• Un valor

Sintaxis básica:

tipo nombreVariable = valor;

Ejemplos:

int edad = 25;
double precio = 19.99;
boolean activo = true;
char letra = 'A';
String nombre = "Juan";  // String es una clase, no un primitivo

Tipos de datos primitivos en Java

Variables: Declaración vs Inicialización

Declaración: Reservar espacio de memoria

int edad;
String nombre;

Inicialización: Asignar un valor inicial

edad = 25;
nombre = "Ana";

Combinados:

int edad = 25;
String nombre = "Ana";

Ejercicio: Declaración de variables

Ejercicio 1: Declara variables para almacenar la siguiente información de un estudiante:

• Nombre
• Edad
• Promedio de calificaciones
• Si está activo o no
• Inicial de su segundo nombre

Luego imprime toda la información.

Alcance de variables (Scope)

El alcance determina dónde es accesible una variable:

Variables locales: Declaradas dentro de un método

public void ejemplo() {
    int x = 10;  // Solo accesible dentro de este método
}

Variables de clase (atributos): Declaradas en la clase, fuera de métodos

public class Ejemplo {
    int y = 20;  // Accesible desde cualquier método de la clase
    
    public void metodo1() {
        System.out.println(y);  // Puede acceder a y
    }
}

Ejemplo de alcance de variables

public class EjemploScope {
    int variableDeClase = 10;  // Variable de clase
    
    public void metodo1() {
        int variableLocal = 20;  // Variable local a metodo1
        System.out.println(variableDeClase);  // Accesible
        System.out.println(variableLocal);    // Accesible
        // System.out.println(otraVariable);  // Error: no existe aquí
    }
    
    public void metodo2() {
        int otraVariable = 30;  // Variable local a metodo2
        System.out.println(variableDeClase);  // Accesible
        // System.out.println(variableLocal);  // Error: fuera de alcance
        
        if (true) {
            int variableDentroDeIf = 40;  // Variable local al bloque if
            System.out.println(variableDentroDeIf);  // Accesible
        }
        // System.out.println(variableDentroDeIf);  // Error: fuera de alcance
    }
}

Constantes en Java

Para declarar una constante, usa la palabra clave final:

final double PI = 3.14159;
final int DIAS_SEMANA = 7;

Características:

• No pueden cambiar su valor después de la inicialización
• Por convención, se nombran en MAYÚSCULAS_CON_GUIONES_BAJOS
• Mejoran la legibilidad y mantenimiento del código

// Intento de modificar una constante
PI = 3.14;  // Error de compilación

Operadores en Java

Operadores aritméticos:

int a = 10;
int b = 3;
System.out.println(a + b);  // 13 (suma)
System.out.println(a - b);  // 7 (resta)
System.out.println(a * b);  // 30 (multiplicación)
System.out.println(a / b);  // 3 (división entera)
System.out.println(a % b);  // 1 (módulo/resto)

Operadores de asignación

int x = 10;  // Asignación simple

// Asignación compuesta
x += 5;      // Equivale a: x = x + 5;  (ahora x vale 15)
x -= 3;      // Equivale a: x = x - 3;  (ahora x vale 12)
x *= 2;      // Equivale a: x = x * 2;  (ahora x vale 24)
x /= 4;      // Equivale a: x = x / 4;  (ahora x vale 6)
x %= 4;      // Equivale a: x = x % 4;  (ahora x vale 2)

Operadores de incremento y decremento

int a = 5;
a++;        // Incremento en 1 (postfijo): a = a + 1; (ahora a vale 6)
++a;        // Incremento en 1 (prefijo):  a = a + 1; (ahora a vale 7)

int b = 8;
b--;        // Decremento en 1 (postfijo): b = b - 1; (ahora b vale 7)
--b;        // Decremento en 1 (prefijo):  b = b - 1; (ahora b vale 6)

La diferencia entre prefijo y postfijo importa en expresiones:

int x = 5;
int y = x++;  // y = 5, x = 6 (asigna primero, luego incrementa)

int m = 5;
int n = ++m;  // n = 6, m = 6 (incrementa primero, luego asigna)

Operadores de comparación

int a = 5;
int b = 7;

System.out.println(a == b);  // false (igualdad)
System.out.println(a != b);  // true (desigualdad)
System.out.println(a > b);   // false (mayor que)
System.out.println(a < b);   // true (menor que)
System.out.println(a >= b);  // false (mayor o igual que)
System.out.println(a <= b);  // true (menor o igual que)

¡Precaución! Para objetos como String, usa el método equals():

String s1 = "Hola";
String s2 = "Hola";
System.out.println(s1 == s2);       // Puede dar true o false (compara referencias)
System.out.println(s1.equals(s2));  // true (compara contenido)

Operadores lógicos

boolean a = true;
boolean b = false;

System.out.println(a && b);  // false (AND lógico - ambos deben ser true)
System.out.println(a || b);  // true (OR lógico - al menos uno debe ser true)
System.out.println(!a);      // false (NOT lógico - invierte el valor)

Ejemplo práctico:

int edad = 25;
boolean tieneLicencia = true;

boolean puedeConducir = edad >= 18 && tieneLicencia;
System.out.println("¿Puede conducir? " + puedeConducir);  // true

Precedencia de operadores

Los operadores se evalúan en un orden específico:

1. Postfijo expr++ expr--
2. Prefijo ++expr --expr +expr -expr !
3. Multiplicativos * / %
4. Aditivos + -
5. Relacionales < > <= >=
6. Igualdad == !=
7. AND lógico &&
8. OR lógico ||
9. Asignación = += -= etc.

Use paréntesis para mejorar la claridad:

int resultado = (a + b) * c;  // Los paréntesis se evalúan primero

Ejercicio: Operadores

Ejercicio 2: Escribe un programa que calcule el área y el perímetro de un rectángulo.

• Declara variables para la base y la altura
• Calcula el área y el perímetro
• Muestra los resultados

Entrada por consola en Java

Para leer entrada del usuario, usamos la clase Scanner:

import java.util.Scanner;

public class EntradaUsuario {
    public static void main(String[] args) {
        // Crear un objeto Scanner
        Scanner scanner = new Scanner(System.in);
        
        // Solicitar datos
        System.out.print("Ingrese su nombre: ");
        String nombre = scanner.nextLine();
        
        System.out.print("Ingrese su edad: ");
        int edad = scanner.nextInt();
        
        // Mostrar los datos ingresados
        System.out.println("Hola " + nombre + ", tienes " + edad + " años.");
        
        // Cerrar el scanner
        scanner.close();
    }
}

Problema común con Scanner

import java.util.Scanner;

public class ProblemaScanner {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        System.out.print("Ingrese su edad: ");
        int edad = scanner.nextInt();  // Lee el número pero deja el salto de línea
        
        // Este nextLine() consume el salto de línea dejado por nextInt()
        scanner.nextLine();
        
        System.out.print("Ingrese su nombre: ");
        String nombre = scanner.nextLine();
        
        System.out.println("Nombre: " + nombre + ", Edad: " + edad);
        
        scanner.close();
    }
}

Parámetros de línea de comandos

Los parámetros pasados al ejecutar el programa se reciben en args:

public class ParametrosComandos {
    public static void main(String[] args) {
        System.out.println("Número de argumentos: " + args.length);
        
        for (int i = 0; i < args.length; i++) {
            System.out.println("Argumento " + i + ": " + args[i]);
        }
    }
}

Para ejecutar con parámetros:

java ParametrosComandos uno dos tres

Ejercicio: Entrada de usuario

Ejercicio 3: Crea un programa que solicite al usuario su nombre, edad y altura en metros. Luego calcula e imprime su índice de masa corporal (IMC).

• Formula: IMC = peso / (altura * altura)
• Solicita peso en kilogramos y altura en metros
• Muestra el IMC con dos decimales

Estructuras de control: Condicionales

if-else: Evalúa una condición y ejecuta código según el resultado

int edad = 18;

if (edad >= 18) {
    System.out.println("Es mayor de edad");
} else {
    System.out.println("Es menor de edad");
}

if-else-if

Para múltiples condiciones:

int nota = 85;

if (nota >= 90) {
    System.out.println("Sobresaliente");
} else if (nota >= 80) {
    System.out.println("Notable");
} else if (nota >= 70) {
    System.out.println("Bien");
} else if (nota >= 60) {
    System.out.println("Suficiente");
} else {
    System.out.println("Insuficiente");
}

Operador ternario

Una forma concisa de expresar condiciones simples:

// Sintaxis: condición ? valorSiTrue : valorSiFalse
int edad = 20;
String estado = (edad >= 18) ? "Mayor de edad" : "Menor de edad";

System.out.println(estado);  // "Mayor de edad"

También se puede usar en asignaciones:

int a = 5;
int b = 7;
int maximo = (a > b) ? a : b;
System.out.println("El máximo es: " + maximo);  // 7

Switch

Para comparar una variable con múltiples valores posibles:

int dia = 3;
String nombreDia;

switch (dia) {
    case 1:
        nombreDia = "Lunes";
        break;
    case 2:
        nombreDia = "Martes";
        break;
    case 3:
        nombreDia = "Miércoles";
        break;
    case 4:
        nombreDia = "Jueves";
        break;
    case 5:
        nombreDia = "Viernes";
        break;
    case 6:
        nombreDia = "Sábado";
        break;
    case 7:
        nombreDia = "Domingo";
        break;
    default:
        nombreDia = "Día inválido";
}

System.out.println("El día " + dia + " es " + nombreDia);

Ejercicio: Condicionales

Ejercicio 4: Crea un programa que determine el tipo de triángulo según sus lados:

• Solicita las longitudes de los tres lados
• Determina si es equilátero (tres lados iguales), isósceles (dos lados iguales) o escaleno (todos diferentes)
• También verifica si los lados pueden formar un triángulo (la suma de dos lados debe ser mayor que el tercero)

Estructuras de control: Bucles

while: Ejecuta un bloque mientras una condición sea verdadera

int contador = 1;

while (contador <= 5) {
    System.out.println("Iteración: " + contador);
    contador++;
}

do-while

Ejecuta un bloque al menos una vez y luego mientras la condición sea verdadera:

int contador = 1;

do {
    System.out.println("Iteración: " + contador);
    contador++;
} while (contador <= 5);

for

El bucle más común para un número conocido de iteraciones:

// for (inicialización; condición; incremento)
for (int i = 0; i < 5; i++) {
    System.out.println("Valor de i: " + i);
}

Equivalente a:

int i = 0;
while (i < 5) {
    System.out.println("Valor de i: " + i);
    i++;
}

for mejorado (for-each)

Para iterar sobre colecciones (arrays, listas, etc.):

String[] nombres = {"Ana", "Juan", "María", "Pedro"};

// Equivalente a "for nombre in nombres:" en Python
for (String nombre : nombres) {
    System.out.println(nombre);
}

break y continue

break: Sale completamente del bucle

for (int i = 1; i <= 10; i++) {
    if (i == 5) {
        break;  // Sale del bucle cuando i es 5
    }
    System.out.println(i);  // Imprime 1, 2, 3, 4
}

continue: Salta a la siguiente iteración

for (int i = 1; i <= 10; i++) {
    if (i % 2 == 0) {
        continue;  // Salta los números pares
    }
    System.out.println(i);  // Imprime 1, 3, 5, 7, 9
}

Ejercicio: Bucles

Ejercicio 5: Crea un programa que imprima la tabla de multiplicar de un número:

• Solicita al usuario un número entero
• Imprime su tabla de multiplicar del 1 al 10
• Usa un bucle for

Arrays en Java

Un array es una colección de elementos del mismo tipo con tamaño fijo:

Declaración e inicialización:

// Declaración
int[] numeros;  // Recomendado
// o
int numeros[];  // Válido pero menos usado

// Inicialización con tamaño
numeros = new int[5];  // Array de 5 enteros (con valores 0)

// Asignación de valores
numeros[0] = 10;
numeros[1] = 20;
numeros[2] = 30;
numeros[3] = 40;
numeros[4] = 50;

// Declaración e inicialización en una línea
int[] primos = {2, 3, 5, 7, 11};

Acceso y propiedades de arrays

int[] numeros = {10, 20, 30, 40, 50};

// Acceso a elementos
System.out.println(numeros[0]);  // 10
System.out.println(numeros[2]);  // 30

// Modificación de elementos
numeros[1] = 25;  // Ahora es {10, 25, 30, 40, 50}

// Longitud del array
System.out.println("Tamaño del array: " + numeros.length);  // 5

// Acceso al último elemento
System.out.println("Último elemento: " + numeros[numeros.length - 1]);  // 50

Iteración sobre arrays

Hay varias formas de recorrer un array:

int[] numeros = {10, 20, 30, 40, 50};

// Usando for tradicional
for (int i = 0; i < numeros.length; i++) {
    System.out.println("numeros[" + i + "] = " + numeros[i]);
}

// Usando for-each (más simple, sin índice)
for (int numero : numeros) {
    System.out.println(numero);
}

Arrays multidimensionales

Java soporta arrays de arrays (matrices):

// Declaración e inicialización
int[][] matriz = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};

// Acceso a elementos
System.out.println(matriz[1][2]);  // 6 (fila 1, columna 2)

// Inicialización con tamaño
int[][] tabla = new int[3][3];  // Matriz 3x3 de ceros

// Asignación de valores
tabla[0][0] = 1;
tabla[0][1] = 2;
// ...

Iteración sobre arrays multidimensionales

int[][] matriz = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};

// Usando for tradicional
for (int i = 0; i < matriz.length; i++) {
    for (int j = 0; j < matriz[i].length; j++) {
        System.out.print(matriz[i][j] + "\t");
    }
    System.out.println();  // Nueva línea después de cada fila
}

// Usando for-each
for (int[] fila : matriz) {
    for (int valor : fila) {
        System.out.print(valor + "\t");
    }
    System.out.println();
}

Métodos útiles para arrays

La clase java.util.Arrays proporciona métodos útiles:

import java.util.Arrays;

public class MetodosArrays {
    public static void main(String[] args) {
        int[] numeros = {5, 2, 8, 1, 9};
        
        // Ordenar
        Arrays.sort(numeros);
        System.out.println(Arrays.toString(numeros));  // [1, 2, 5, 8, 9]
        
        // Buscar (en array ordenado)
        int indice = Arrays.binarySearch(numeros, 5);
        System.out.println("5 está en el índice " + indice);  // 2
        
        // Llenar
        int[] cincos = new int[5];
        Arrays.fill(cincos, 5);
        System.out.println(Arrays.toString(cincos));  // [5, 5, 5, 5, 5]
        
        // Comparar
        int[] a = {1, 2, 3};
        int[] b = {1, 2, 3};
        System.out.println("¿Arrays iguales? " + Arrays.equals(a, b));  // true
    }
}

Ejercicio: Arrays

Ejercicio 6: Crea un programa que:

• Defina un array de 10 números enteros
• Calcule la suma y el promedio de los elementos
• Encuentre el valor máximo y mínimo
• Cuente cuántos números son pares

Comentarios en Java

Java soporta tres tipos de comentarios:

// Comentario de una línea

/*
 * Comentario de
 * múltiples líneas
 */

/**
 * Comentario de documentación (Javadoc)
 * @author Nombre del Autor
 * @version 1.0
 */

Javadoc: Comentarios de documentación

Usados para generar documentación automática:

/**
 * Esta clase calcula áreas de figuras geométricas.
 * @author Juan Pérez
 * @version 1.0
 */
public class Geometria {
    
    /**
     * Calcula el área de un círculo.
     * 
     * @param radio El radio del círculo en cm
     * @return El área del círculo en cm²
     */
    public double areaCirculo(double radio) {
        return Math.PI * radio * radio;
    }
}

Buenas prácticas de comentarios

✅ Lo recomendado:

• Comentar el porqué, no el qué
• Mantener comentarios actualizados con el código
• Usar Javadoc para documentar APIs
• Comentar código complejo o no intuitivo
• Usar comentarios para TODO, FIXME, etc.

❌ Lo que se debe evitar:

• Comentarios obvios (x++; // Incrementa x)
• Comentarios desactualizados
• Código comentado (usar control de versiones)
• Comentarios excesivos

Depuración en Java

La depuración (debugging) es el proceso de encontrar y corregir errores:

Tipos de errores:

1. Errores de compilación: Detectados antes de ejecutar el programa
2. Errores en tiempo de ejecución: Ocurren durante la ejecución (excepciones)
3. Errores lógicos: El programa funciona pero no hace lo esperado

Errores comunes de compilación

// Error: punto y coma faltante
int x = 5
System.out.println(x);

// Error: llaves desbalanceadas
if (x > 0) {
    System.out.println("Positivo");
    // Falta llave de cierre

// Error: tipo incorrecto
int y = "Hola";  // No se puede asignar String a int

// Error: variable no declarada
z = 10;  // z no ha sido declarada

// Error: nombre mal escrito
System.out.prntln("Texto");  // Método inexistente

Excepciones comunes

// ArrayIndexOutOfBoundsException
int[] array = {1, 2, 3};
System.out.println(array[3]);  // El índice 3 no existe

// NullPointerException
String texto = null;
System.out.println(texto.length());  // No se puede llamar métodos en null

// ArithmeticException
int division = 10 / 0;  // División por cero

// NumberFormatException
int numero = Integer.parseInt("abc");  // "abc" no es un número

// InputMismatchException
Scanner scanner = new Scanner(System.in);
int x = scanner.nextInt();  // Si el usuario ingresa texto

Uso de println para depuración

Una técnica simple pero efectiva:

public int calcularTotal(int[] precios) {
    System.out.println("Iniciando cálculo del total");
    
    int suma = 0;
    for (int i = 0; i < precios.length; i++) {
        System.out.println("Procesando índice " + i + ", valor: " + precios[i]);
        suma += precios[i];
    }
    
    System.out.println("Suma total: " + suma);
    return suma;
}

Depuración con IntelliJ IDEA

1. Puntos de interrupción (breakpoints): Click en el margen izquierdo
2. Iniciar sesión de depuración: Click en “Debug” en lugar de “Run”
3. Controles de ejecución:
   • Step Over (F8): Ejecutar la línea actual y pasar a la siguiente
   • Step Into (F7): Entrar en un método
   • Step Out (Shift+F8): Salir del método actual
   • Resume (F9): Continuar hasta el próximo breakpoint
4. Inspección de variables: Ver valores actuales en la ventana “Variables”

Consejos para depuración efectiva

1. Reproducir el error: Encuentra pasos específicos que causan el problema
2. Divide y vencerás: Aísla la sección problemática
3. Prueba con casos simples: Reduce la complejidad
4. Usa la depuración interactiva: Breakpoints en puntos estratégicos
5. Verifica tus suposiciones: No asumas, confirma
6. Lee cuidadosamente los mensajes de error: Contienen pistas valiosas
7. Busca patrones: ¿Ocurre bajo ciertas condiciones?
8. Toma descansos: A veces la solución llega cuando te alejas

Ejercicio práctico: Contador de palabras

Crearemos un programa que analice un texto:

1. Contar número de palabras
2. Contar número de caracteres (sin espacios)
3. Encontrar la palabra más larga

import java.util.Scanner;

public class ContadorPalabras {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        System.out.println("Ingrese un texto:");
        String texto = scanner.nextLine();
        
        // Dividir el texto en palabras
        String[] palabras = texto.split("\\s+");
        
        // Contar palabras
        int numPalabras = palabras.length;
        
        // Contar caracteres (sin espacios)
        int numCaracteres = texto.replaceAll("\\s+", "").length();
        
        // Encontrar palabra más larga
        String palabraMasLarga = "";
        for (String palabra : palabras) {
            if (palabra.length() > palabraMasLarga.length()) {
                palabraMasLarga = palabra;
            }
        }
        
        // Mostrar resultados
        System.out.println("\nAnálisis completado:");
        System.out.println("Número de palabras: " + numPalabras);
        System.out.println("Número de caracteres (sin espacios): " + numCaracteres);
        System.out.println("Palabra más larga: '" + palabraMasLarga + "' (" + 
                          palabraMasLarga.length() + " caracteres)");
        
        scanner.close();
    }
}

Ejercicio práctico: Juego de adivinanzas

Crearemos un juego simple donde el jugador debe adivinar un número aleatorio:

import java.util.Scanner;
import java.util.Random;

public class JuegoAdivinanza {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        Random random = new Random();
        
        // Generar número aleatorio entre 1 y 100
        int numeroSecreto = random.nextInt(100) + 1;
        int intentos = 0;
        boolean adivinado = false;
        
        System.out.println("¡Bienvenido al juego de adivinanzas!");
        System.out.println("He pensado un número entre 1 y 100.");
        
        while (!adivinado && intentos < 10) {
            System.out.print("Intento " + (intentos + 1) + ": Ingresa tu número: ");
            
            // Manejo de entrada inválida
            if (!scanner.hasNextInt()) {
                System.out.println("Por favor, ingresa un número válido.");
                scanner.next(); // Descartar entrada inválida
                continue;
            }
            
            int intento = scanner.nextInt();
            intentos++;
            
            if (intento < 1 || intento > 100) {
                System.out.println("Por favor, ingresa un número entre 1 y 100.");
            } else if (intento < numeroSecreto) {
                System.out.println("El número es mayor.");
            } else if (intento > numeroSecreto) {
                System.out.println("El número es menor.");
            } else {
                adivinado = true;
                System.out.println("¡Correcto! Has adivinado en " + intentos + " intentos.");
            }
        }
        
        if (!adivinado) {
            System.out.println("¡Has agotado tus 10 intentos! El número era: " + numeroSecreto);
        }
        
        scanner.close();
    }
}