TUTORIAL COMPLETO PARA APRENDER PROGRAMACIÓN EN JAVA DESDE CERO
Introducción a la Programación en Java
La programación en Java representa una puerta de entrada fundamental al mundo del desarrollo de software. Este lenguaje, conocido por su robustez y versatilidad, permite a los desarrolladores crear aplicaciones que se ejecutan en cualquier plataforma sin modificaciones significativas. Desde sus inicios en la década de 1990, Java ha evolucionado para convertirse en una herramienta esencial en entornos empresariales, móviles y web. En este tutorial, exploraremos los aspectos clave de Java, actualizados a la versión 23, que introduce mejoras en el rendimiento y la concurrencia, como hilos virtuales que facilitan la programación paralela para tareas complejas.
Para los principiantes, Java ofrece una curva de aprendizaje estructurada gracias a su tipado fuerte y su enfoque en la orientación a objetos. Esto significa que cada variable debe declararse con un tipo específico, lo que previene errores comunes y promueve código más limpio. Imagina construir un edificio: Java proporciona los bloques sólidos desde el principio, asegurando que la estructura sea estable. A lo largo de este recorrido, nos centraremos en conceptos prácticos que puedes aplicar inmediatamente en un editor de código o incluso en un entorno en línea.
Aprender java programacion lenguaje es un paso clave para quienes aspiran a carreras en tecnología. Con más de treinta años de historia, Java soporta ecosistemas masivos como Android y servidores empresariales. En 2025, con la adopción de Java 23, los desarrolladores disfrutan de características como el matching de patrones mejorado, que simplifica el procesamiento de datos complejos. Este tutorial está diseñado para guiarte paso a paso, incorporando ejemplos de código que ilustran cada concepto. No se requiere experiencia previa; solo curiosidad y disposición para experimentar.
Comencemos por entender por qué Java destaca en el panorama actual. Su compilación a bytecode permite la ejecución en la Máquina Virtual de Java (JVM), garantizando portabilidad. Esto es particularmente útil en equipos distribuidos, donde el código debe funcionar en Windows, Linux o macOS sin ajustes. Además, la comunidad de Java es vasta, ofreciendo recursos gratuitos y foros para resolver dudas. Para maximizar tu aprendizaje, dedica tiempo a ejecutar los ejemplos proporcionados, modificándolos para ver cómo responden los cambios.
En las secciones siguientes, desglosaremos los pilares de Java: desde la creación de programas simples hasta la implementación de estructuras avanzadas. Cada tema incluye explicaciones detalladas, consejos para depuración y ejemplos que demuestran aplicaciones reales. Por ejemplo, aprenderás a manejar entradas de usuario para crear programas interactivos, esenciales en aplicaciones modernas. Al finalizar, tendrás las herramientas para desarrollar proyectos independientes, como un gestor de tareas o un simulador básico.
La programación en Java no solo enseña sintaxis, sino principios de diseño de software. Conceptos como la encapsulación protegen datos internos, mientras que la herencia permite reutilizar código eficientemente. En Java 23, estas ideas se potencian con clases selladas, que restringen la herencia para mayor seguridad. Este enfoque profesional asegura que tu código sea mantenible a largo plazo, un requisito en industrias competitivas.
Hola Mundo en Java
El primer paso en cualquier lenguaje de programación es escribir un programa que salude al mundo. En Java, esto se logra mediante una clase principal que contiene el método main, el punto de entrada de la ejecución. Este ritual introduce la estructura básica: declaración de paquetes, imports opcionales y el cuerpo del programa. En la versión 23 de Java, puedes usar bloques de texto multilínea para outputs más limpios, aunque para un Hola Mundo simple, un println basta.
Considera el siguiente ejemplo de código, que imprime “Hola Mundo” en la consola:
public class HolaMundo {
public static void main(String[] args) {
System.out.println("Hola Mundo");
}
}
Para compilar y ejecutar, guarda este código en un archivo llamado HolaMundo.java, luego usa el comando javac HolaMundo.java seguido de java HolaMundo en la terminal. Si estás en un entorno en línea como Replit o JDoodle, simplemente pega el código y presiona run. Este proceso revela la compilación: el archivo .class generado contiene el bytecode interpretable por la JVM.
Perfecto para principiantes totales este ejercicio establece confianza inmediata. Observa que public static void main es obligatorio; public indica accesibilidad global, static permite ejecución sin instanciar la clase, y void significa que no retorna valor. Los args son argumentos de línea de comandos, útiles para personalizar ejecuciones futuras.
Expande este programa agregando múltiples líneas de salida. Por ejemplo, incluye tu nombre:
public class HolaMundoPersonalizado {
public static void main(String[] args) {
System.out.println("Hola Mundo");
System.out.println("Mi nombre es [Tu Nombre]");
System.out.println("Estoy aprendiendo Java en 2025");
}
}
Ejecuta y nota cómo cada println avanza a una nueva línea. Para depurar, si olvidas el punto y coma, el compilador te alertará con errores claros, una fortaleza de Java. En contextos reales, este patrón se usa en logs de aplicaciones para rastrear flujos de ejecución.
La simplicidad de Hola Mundo oculta lecciones profundas sobre convención en programación. Java exige nombres de clases que coincidan con archivos, fomentando organización. En proyectos grandes, esto escala a paquetes como com.ejemplo.hola, importados con import. Practica variando el mensaje para internalizar la sintaxis.
En el ámbito profesional, programas como este sirven de base para scripts de automatización. Con Java 23, integra hilos virtuales para outputs concurrentes, aunque para principiantes, enfócate en lo secuencial. Dedica tiempo a leer la salida: entender que System.out es un objeto que invoca métodos ilustra la orientación a objetos temprana.
Este fundamento prepara el terreno para variables y tipos de datos, donde personalizaremos salidas dinámicamente. Recuerda, la práctica consistente transforma conocimiento teórico en habilidad práctica.
Variables en Java
Las variables son contenedores nombrados que almacenan datos en memoria durante la ejecución del programa. En Java, declaras una variable especificando su tipo, nombre y opcionalmente un valor inicial. Esto refleja el tipado estático: el compilador verifica tipos en tiempo de compilación, reduciendo errores en runtime. En Java 23, las inferencias de tipo mejoradas con var simplifican declaraciones sin sacrificar claridad.
Por ejemplo, declara una variable entera:
public class VariablesEjemplo {
public static void main(String[] args) {
int edad = 25;
System.out.println("Mi edad es: " + edad);
}
}
Aquí, int define un entero de 32 bits, y el operador + concatena para salida. Asigna valores dinámicos modificando edad y reejecuta para ver cambios.
Variables esenciales programacion java capturan estados cambiantes en aplicaciones. Para flotantes, usa double:
public class VariablesFlotantes {
public static void main(String[] args) {
double altura = 1.75;
System.out.println("Mi altura es: " + altura + " metros");
}
}
El sufijo implícito para doubles asegura precisión decimal. Evita float para cálculos exactos, ya que double ofrece más rango. En contextos reales, variables modelan entidades como saldos bancarios o coordenadas geográficas.
Explora alcance: variables locales viven solo dentro de bloques {}. Declara una fuera del main para campos de clase:
public class ClaseConCampo {
int contador = 0; // Campo de instancia
public static void main(String[] args) {
ClaseConCampo obj = new ClaseConCampo();
System.out.println("Contador inicial: " + obj.contador);
}
}
Esto introduce instanciación, puente a objetos. Nombra variables descriptivamente, como totalVentas en lugar de x, para legibilidad. Java es case-sensitive: Edad difiere de edad.
En depuración, usa System.out.println(variable) para inspeccionar valores. Para constantes, precede con final: final double PI = 3.14159;. Esto previene reasignaciones accidentales, común en configuraciones.
Aplica en un programa que calcule área de un círculo:
public class AreaCirculo {
public static void main(String[] args) {
final double PI = 3.14159;
double radio = 5.0;
double area = PI * radio * radio;
System.out.println("El área es: " + area);
}
}
Este ejemplo integra variables con matemáticas básicas. En Java 23, usa text blocks para mensajes multilínea:
String mensaje = """
Calculando área:
Radio: %.2f
Área: %.2f
""".formatted(radio, area);
System.out.println(mensaje);
Requiere import java.util.Formatter implícito. Estas variables dinámicas escalan a algoritmos complejos. Practica declarando diez variables de tipos mixtos, imprimiéndolas para familiarizarte.
El manejo correcto de variables previene fugas de memoria y optimiza rendimiento. En equipos, sigue convenciones como camelCase para locales. Con esto, transitas a tipos de datos, profundizando en opciones de almacenamiento.
Tipos de Datos en Java
Java clasifica datos en primitivos y de referencia, cada uno con propósitos específicos. Primitivos incluyen byte, short, int, long para números enteros; float, double para fraccionarios; char para caracteres; boolean para verdadero/falso. Referencias como String o arrays apuntan a objetos en heap. En Java 23, primitivos se benefician de unboxing mejorado para interacciones fluidas.
Ejemplo con primitivos:
public class TiposPrimitivos {
public static void main(String[] args) {
int entero = 100;
double decimal = 3.14;
char letra = 'A';
boolean activo = true;
System.out.println("Entero: " + entero);
System.out.println("Decimal: " + decimal);
System.out.println("Letra: " + letra);
System.out.println("Activo: " + activo);
}
}
Cada tipo tiene límites: int va de -2^31 a 2^31-1. Usa long para números grandes, agregando L: long grande = 10000000000L;. Boolean es crucial para condiciones, retornando solo true/false.
Para referencias, String es inmutable:
public class TiposReferencia {
public static void main(String[] args) {
String nombre = "Juan";
System.out.println("Nombre: " + nombre.length() + " caracteres");
String apellido = new String("Pérez"); // Forma explícita
System.out.println("Apellido: " + apellido.toUpperCase());
}
}
length() cuenta caracteres; toUpperCase() transforma. Inmutabilidad asegura thread-safety en concurrencia. En Java 23, strings soportan interpolación con formatted.
Fuertes tipos class-based definen la esencia de Java. Mezcla tipos en expresiones: double suma = entero + decimal;. Cuidado con overflows: casting explícito (int)decimal trunca.
Aplica en un perfil usuario:
public class PerfilUsuario {
public static void main(String[] args) {
String email = "[email protected]";
int edad = 30;
boolean premium = false;
char inicial = email.charAt(0);
System.out.println("Inicial: " + inicial + ", Edad: " + edad + ", Premium: " + premium);
}
}
charAt(0) extrae el primer carácter. Para arrays primitivos:
int[] numeros = {1, 2, 3};
System.out.println("Primer número: " + numeros[0]);
Esto anticipa arrays. Elige tipos por eficiencia: byte para datos pequeños ahorra memoria. En desarrollo web, double modela precios; boolean flags de usuario.
Depura con IDEs como IntelliJ, que destacan tipos. Java 23 introduce previews para tipos unión, pero quédate con básicos. Experimenta convirtiendo tipos: String.valueOf(entero) a string.
Dominar tipos habilita manipulaciones precisas, base para operadores que actúan sobre ellos.
Operadores en Java
Los operadores realizan operaciones en operandos, categorizados en aritméticos, relacionales, lógicos y de asignación. Aritméticos como +, -, *, /, % manejan cálculos; relacionales (==, !=, >, <) comparan; lógicos (&&, ||, !) combinan booleanos; asignación (=, +=) actualiza variables.
Ejemplo aritmético:
public class OperadoresAritmeticos {
public static void main(String[] args) {
int a = 10;
int b = 3;
System.out.println("Suma: " + (a + b));
System.out.println("Resta: " + (a - b));
System.out.println("Multiplicación: " + (a * b));
System.out.println("División: " + (a / b));
System.out.println("Módulo: " + (a % b));
}
}
Paréntesis aseguran precedencia. División entera trunca; usa double para fracciones. Módulo es útil para ciclos.
Relacionales:
public class OperadoresRelacionales {
public static void main(String[] args) {
int x = 5;
int y = 7;
System.out.println("x == y: " + (x == y));
System.out.println("x > y: " + (x > y));
System.out.println("x <= y: " + (x <= y));
}
}
Retornan boolean. Lógicos:
public class OperadoresLogicos {
public static void main(String[] args) {
boolean p = true;
boolean q = false;
System.out.println("p && q: " + (p && q));
System.out.println("p || q: " + (p || q));
System.out.println("!p: " + (!p));
}
}
&& es AND corto-circuito, evaluando solo si necesario. Asignación compuesta:
int valor = 0;
valor += 5; // valor = valor + 5
System.out.println("Valor incrementado: " + valor);
Eficiencia en loops. Operadores esenciales logica programacion potencian decisiones complejas. En un calculador simple:
public class CalculadoraBasica {
public static void main(String[] args) {
double num1 = 10.5;
double num2 = 4.2;
double resultado = (num1 + num2) * num2 - num1 / 2;
System.out.println("Resultado: " + resultado);
}
}
Precedencia: * / antes + -. Usa paréntesis para claridad. En Java 23, operadores en switches mejorados.
Para strings, + concatena: "Hola " + nombre. Evita en loops por ineficiencia; usa StringBuilder.
Practica combinando: un operador lógico en condición de descuento si edad > 18 && ingresos > 50000. Esto construye lógica empresarial.
Operadores son el pegamento de expresiones; maestrarlos acelera codificación.
Cadenas de Texto en Java
Las cadenas, o strings, manejan secuencias de caracteres inmutables, ideales para texto. Declaradas con comillas dobles, soportan métodos como length(), substring(), replace(). En Java 23, text blocks permiten multilínea sin escapes.
Ejemplo básico:
public class CadenasBasicas {
public static void main(String[] args) {
String saludo = "Hola, mundo Java";
System.out.println("Longitud: " + saludo.length());
System.out.println("Mayúsculas: " + saludo.toUpperCase());
System.out.println("Minúsculas: " + saludo.toLowerCase());
}
}
length() retorna int; toUpperCase() transforma. Concatenación:
String nombre = "Ana";
String mensaje = "Bienvenida, " + nombre + "!";
System.out.println(mensaje);
Para eficiencia en loops, usa StringBuilder:
StringBuilder sb = new StringBuilder();
sb.append("Construyendo ");
sb.append("cadena ");
sb.append("dinámicamente");
System.out.println(sb.toString());
Evita + repetido. Manipulacion cadenas texto java es clave en procesamiento de datos. Substring extrae partes:
String texto = "Programación en Java";
String sub = texto.substring(0, 11); // "Programación"
System.out.println(sub);
Índice 0 a 11 (exclusivo). Reemplazo:
String corregido = texto.replace("en", "con");
System.out.println(corregido); // "Programación con Java"
Útil para sanitización. Comparación: equals() para contenido, == para referencias.
En Java 23, formatted strings:
String formato = "Edad: %d, Nombre: %s".formatted(25, "Carlos");
System.out.println(formato);
Mejora legibilidad. Para validación email:
String email = "[email protected]";
if (email.contains("@") && email.endsWith(".com")) {
System.out.println("Email válido");
}
Métodos como contains(), startsWith(). En apps web, strings serializan JSON.
Practica: construye un generador de contraseñas concatenando aleatorios. Usa indexOf() para buscar posiciones.
Cadenas inmutables promueven seguridad; entiéndelas para UI y APIs.
Entradas de Usuario en Java
Interactuar con usuarios eleva programas estáticos a dinámicos. Usa Scanner de java.util para leer consola, soportando ints, strings, etc. En Java 23, mejoras en I/O facilitan lecturas seguras.
Importa primero:
import java.util.Scanner;
public class EntradasBasicas {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("Ingresa tu nombre: ");
String nombre = scanner.nextLine();
System.out.println("Hola, " + nombre);
scanner.close();
}
}
nextLine() lee hasta enter. Para números:
System.out.print("Ingresa un número: ");
int numero = scanner.nextInt();
System.out.println("Doble: " + (numero * 2));
Maneja excepciones si input no numérico. Entradas usuario interactivas java enriquecen experiencias. Ejemplo completo:
import java.util.Scanner;
public class CalculadoraEntrada {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("Número 1: ");
double num1 = scanner.nextDouble();
System.out.print("Número 2: ");
double num2 = scanner.nextDouble();
System.out.println("Suma: " + (num1 + num2));
scanner.close();
}
}
Cierra scanner para liberar recursos. Para validación:
try {
int edad = scanner.nextInt();
if (edad < 0) {
System.out.println("Edad inválida");
}
} catch (Exception e) {
System.out.println("Entrada no numérica");
}
Anticipa try-catch. En GUIs, esto evoluciona a JOptionPane, pero consola basta para basics.
Practica: programa que lee múltiples líneas, procesándolas. Usa next() para palabras.
Entradas habilitan apps como chats simples, base para servidores.
Estructuras Condicionales en Java
Las condicionales dirigen flujo basado en booleanos: if, else if, else. Evalúan expresiones para ejecutar bloques selectivos, esencial para lógica de negocio.
Ejemplo simple:
public class CondicionalesBasicas {
public static void main(String[] args) {
int temperatura = 25;
if (temperatura > 30) {
System.out.println("Calor");
} else if (temperatura < 10) {
System.out.println("Frío");
} else {
System.out.println("Templado");
}
}
}
Anida para complejidad. Con entrada:
import java.util.Scanner;
public class CondicionalEntrada {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("Ingresa edad: ");
int edad = scanner.nextInt();
if (edad >= 18) {
System.out.println("Adulto");
} else {
System.out.println("Menor");
}
scanner.close();
}
}
Condicionales decisiones programacion java modelan escenarios reales. Usa && para múltiples condiciones:
if (edad >= 18 && edad <= 65) {
System.out.println("Edad laboral");
}
|| para OR. Ternario para brevedad: String estado = (edad >= 18) ? "Adulto" : "Menor";.
En e-commerce, condicionales validan carritos. Practica: clasificador de notas (A-F) con if-else chain.
Anidamiento excesivo complica; refactoriza a métodos. Java 23 switches cubren multi-condiciones.
Condicionales infunden inteligencia a código, preparando para loops.
Casos Switch en Java
Switch maneja multi-rutas eficientemente, mejor que cadenas if-else. En Java 23, expressions con yield y patterns.
Ejemplo tradicional:
public class SwitchBasico {
public static void main(String[] args) {
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;
default:
System.out.println("Otro día");
}
}
}
break previene fall-through. Para strings:
String color = "rojo";
switch (color) {
case "rojo":
System.out.println("Peligro");
break;
case "verde":
System.out.println("Seguro");
break;
default:
System.out.println("Desconocido");
}
En Java 23, switch expression:
String resultado = switch (dia) {
case 1 -> "Lunes";
case 2 -> "Martes";
default -> "Fin de semana";
};
System.out.println(resultado);
-> para bodies simples. Switch eficiencia branching java optimiza menús.
Ejemplo menú:
import java.util.Scanner;
public class MenuSwitch {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("Opción (1-3): ");
int opcion = scanner.nextInt();
String accion = switch (opcion) {
case 1 -> "Agregar";
case 2 -> "Eliminar";
case 3 -> "Listar";
default -> "Inválida";
};
System.out.println("Acción: " + accion);
scanner.close();
}
}
Integra con entradas. Patterns en 23 permiten matching: case Integer i when i > 0.
Usa para parsers o routers. Compara rendimiento: switch es más rápido para muchos cases.
Practica: switch para calculadora operaciones (+,-,*,/).
Switch estructura código legible, complementando condicionales.
Arreglos en Java
Arreglos almacenan colecciones fijas de elementos del mismo tipo, indexados desde 0. Declarados con [], inicializados con {} o new.
Ejemplo declaración:
public class ArreglosBasicos {
public static void main(String[] args) {
int[] numeros = {1, 2, 3, 4, 5};
System.out.println("Primer elemento: " + numeros[0]);
System.out.println("Longitud: " + numeros.length);
}
}
length es propiedad. Inicialización dinámica:
int[] pares = new int[5];
for (int i = 0; i < pares.length; i++) {
pares[i] = 2 * (i + 1);
}
Esto anticipa loops. Arreglos colecciones datos java manejan listas. Multidimensionales:
int[][] matriz = {{1, 2}, {3, 4}};
System.out.println(matriz[0][1]); // 2
Para matrices. Copia: usa System.arraycopy para evitar referencias compartidas.
Ejemplo suma elementos:
int suma = 0;
for (int num : numeros) { // Enhanced for
suma += num;
}
System.out.println("Suma: " + suma);
Enhanced for itera sin índice. Errores comunes: IndexOutOfBoundsException; siempre verifica < length.
En análisis de datos, arreglos procesan series temporales. Java 23 optimiza accesos.
Practica: arreglo de strings para nombres, imprimiendo en reverso.
Arreglos son base para estructuras dinámicas como ArrayList.
Bucles For en Java
Bucles for iteran un número conocido de veces, con inicialización, condición y incremento. Ideal para arreglos.
Ejemplo clásico:
public class BucleFor {
public static void main(String[] args) {
for (int i = 0; i < 5; i++) {
System.out.println("Iteración: " + i);
}
}
}
i inicial 0, condición i<5, i++ post-loop. Para arreglos:
int[] nums = {10, 20, 30};
for (int i = 0; i < nums.length; i++) {
System.out.println(nums[i]);
}
Control preciso. Enhanced for:
for (int num : nums) {
System.out.println(num);
}
Simplifica lectura. Bucles for iteracion eficiente en procesamiento. Descendente:
for (int i = 4; i >= 0; i--) {
System.out.println(i);
}
Útil para stacks. Anidado para tablas:
for (int fila = 0; fila < 3; fila++) {
for (int col = 0; col < 3; col++) {
System.out.print(fila + "," + col + " ");
}
System.out.println();
}
Imprime matriz. Evita off-by-one: prueba límites.
En algoritmos, for suma factorial:
int factorial = 1;
for (int i = 1; i <= 5; i++) {
factorial *= i;
}
System.out.println("5! = " + factorial);
Recursión alternativa, pero loops evitan stack overflow. Java 23 paraleliza con streams, pero basics primero.
Practica: for que imprime tablas multiplicar.
For estructura iteraciones predecibles, esencial en data processing.
Bucles While en Java
While ejecuta mientras condición sea true, para iteraciones desconocidas. Verifica antes de cuerpo.
Ejemplo:
public class BucleWhile {
public static void main(String[] args) {
int contador = 0;
while (contador < 5) {
System.out.println("Contador: " + contador);
contador++;
}
}
}
Asegura incremento para evitar infinito. Con entrada:
import java.util.Scanner;
public class WhileEntrada {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int suma = 0;
System.out.println("Ingresa números (0 para parar):");
int num;
while ((num = scanner.nextInt()) != 0) {
suma += num;
}
System.out.println("Suma: " + suma);
scanner.close();
}
}
Lee hasta 0. Bucles while condiciones dinamicas para menús. Do-while ejecuta al menos una vez:
Ver while después. While en validación:
String input;
do {
System.out.print("Ingresa sí/no: ");
input = scanner.nextLine();
} while (!input.equals("sí") && !input.equals("no"));
Esto es do-while. Para while puro, loop hasta break.
En simulaciones, while modela hasta convergencia. Cuidado con busy-waiting; usa sleep en threads.
Practica: while que adivina número, pidiendo inputs.
While adapta a flujos impredecibles.
Bucles Do While en Java
Do-while invierte chequeo: ejecuta cuerpo primero, luego condición. Garantiza al menos una iteración.
Ejemplo:
public class BucleDoWhile {
public static void main(String[] args) {
int numero = 0;
do {
System.out.println("Ejecutando: " + numero);
numero++;
} while (numero < 3);
}
}
Corre tres veces. Para menús:
import java.util.Scanner;
public class MenuDoWhile {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int opcion;
do {
System.out.println("1. Agregar\n2. Salir");
opcion = scanner.nextInt();
switch (opcion) {
case 1 -> System.out.println("Agregado");
}
} while (opcion != 2);
scanner.close();
}
}
Muestra menú al menos una vez. Do while validacion usuario ideal para prompts. Diferencia con while: do-while para chequeo post-ejecución.
En juegos, do-while maneja turnos hasta fin. Combina con break/continue:
int i = 0;
do {
if (i == 2) {
i++;
continue;
}
System.out.println(i);
i++;
} while (i < 5);
Salta 2. Evita infinitos con logs.
Practica: do-while para PIN entrada, limitando intentos.
Do-while añade flexibilidad a control de flujo.
ArrayList en Java
ArrayList es colección dinámica de java.util, creciendo automáticamente. Mejor que arreglos para tamaños variables.
Importa:
import java.util.ArrayList;
public class ArrayListBasico {
public static void main(String[] args) {
ArrayList<String> lista = new ArrayList<>();
lista.add("Manzana");
lista.add("Banana");
System.out.println("Elemento 0: " + lista.get(0));
System.out.println("Tamaño: " + lista.size());
}
}
add() agrega al final; get(index) accede. Arraylist dinamico colecciones java para listas crecientes. Remove:
lista.remove("Banana");
System.out.println(lista); // [Manzana]
toString() implícito. Iterar:
for (String fruta : lista) {
System.out.println(fruta);
}
O con forEach en Java 8+: lista.forEach(System.out::println);.
Ejemplo inventario:
ArrayList<Integer> precios = new ArrayList<>();
precios.add(10);
precios.add(20);
int total = 0;
for (int p : precios) {
total += p;
}
System.out.println("Total: " + total);
Genéricos tipan contenido. En Java 23, streams mejoran: long sum = precios.stream().mapToLong(Integer::intValue).sum();.
Maneja duplicados; usa HashSet para únicos. Capacidad inicial: new ArrayList<>(100) prealoca.
Practica: ArrayList de tareas, agregando/removiendo.
ArrayList potencia apps data-driven.
HashMap en Java
HashMap almacena pares clave-valor, con acceso O(1) promedio. Útil para diccionarios.
Importa:
import java.util.HashMap;
public class HashMapBasico {
public static void main(String[] args) {
HashMap<String, Integer> edades = new HashMap<>();
edades.put("Ana", 25);
edades.put("Bob", 30);
System.out.println("Edad Ana: " + edades.get("Ana"));
}
}
put() inserta; get(key) recupera. Hashmap mapeo clave valor para configs. Contiene:
if (edades.containsKey("Ana")) {
System.out.println("Existe");
}
Iterar:
for (String key : edades.keySet()) {
System.out.println(key + ": " + edades.get(key));
}
O entrySet(). Remover: remove(key). Null keys permitidos, pero evítalos.
Ejemplo teléfono:
HashMap<String, String> contactos = new HashMap<>();
contactos.put("Juan", "123-456");
System.out.println(contactos.get("Juan"));
En caching, HashMap acelera lookups. Java 23 LinkedHashMap para orden.
Maneja colisiones internamente. Tamaño: size().
Practica: HashMap de productos-precios, calculando total.
HashMap organiza datos relacionales eficientemente.
Programación Orientada a Objetos en Java
OOP modela mundo real con clases y objetos: encapsulación, herencia, polimorfismo, abstracción. Clases definen blueprints; objetos instancias.
Ejemplo clase:
public class Perro {
private String nombre; // Encapsulación
public Perro(String nombre) {
this.nombre = nombre;
}
public void ladrar() {
System.out.println(nombre + " dice: Guau!");
}
public String getNombre() {
return nombre;
}
}
class Main {
public static void main(String[] args) {
Perro miPerro = new Perro("Fido");
miPerro.ladrar();
System.out.println("Nombre: " + miPerro.getNombre());
}
}
Constructor inicializa; getters/setters acceden. Conceptos oop java avanzados habilitan modularidad. Herencia:
public class Animal {
public void comer() {
System.out.println("Comiendo");
}
}
public class Perro extends Animal {
public void ladrar() {
System.out.println("Guau");
}
}
extends hereda. Polimorfismo: Animal a = new Perro(); a.comer();
Abstracción con abstract class o interface:
interface Volador {
void volar();
}
public class Pajaro extends Animal implements Volador {
public void volar() {
System.out.println("Volando");
}
}
Múltiples interfaces. En Java 23, records para DTOs: record Punto(int x, int y) {}
Ejemplo sistema banco:
class Cuenta {
protected double saldo;
public Cuenta(double inicial) {
saldo = inicial;
}
public void depositar(double monto) {
saldo += monto;
}
public double getSaldo() {
return saldo;
}
}
class CuentaAhorro extends Cuenta {
private double tasa;
public CuentaAhorro(double inicial, double tasa) {
super(inicial);
this.tasa = tasa;
}
public void aplicarInteres() {
saldo += saldo * tasa;
}
}
Usa super() para constructor padre. Polimorfismo en lista: ArrayList cuentas.
Encapsulación con private/protected. Sobrescribe con @Override.
Practica: clase Vehiculo con subclases Coche, Moto.
OOP escala código a enterprise, promoviendo reutilización.
Conclusiones
En resumen, dominar Java desde los fundamentos hasta OOP equipa a los programadores con habilidades versátiles para el desarrollo moderno. Hemos cubierto desde Hola Mundo hasta colecciones dinámicas, incorporando ejemplos que ilustran aplicaciones prácticas. Con Java 23, estas herramientas se vuelven aún más potentes, preparando para desafíos como concurrencia y big data. La clave reside en la práctica consistente: modifica códigos, depura errores y construye proyectos personales. Este conocimiento no solo abre puertas a empleos en tecnología, sino que fomenta un pensamiento lógico transferable. Continúa explorando, contribuyendo a open source y manteniéndote actualizado con releases anuales de Java. Tu viaje en programación apenas comienza; úsalo para innovar y resolver problemas reales en el ecosistema digital.
