Java para Dummies

Entorno de Desarrollo y Conceptos Base

Java es un lenguaje de alto nivel, fuertemente tipado y orientado a objetos. Para desarrollar, es esencial instalar el JDK (Java Development Kit), que incluye la JVM (Java Virtual Machine) para la portabilidad del código y el JRE (Java Runtime Environment). Utilizaremos IDEs como IntelliJ, NetBeans o Eclipse para la gestión de proyectos.

Tipos de Datos y Variables

A diferencia de lenguajes dinámicos, en Java es obligatorio declarar el tipo de dato y finalizar cada instrucción con punto y coma (;). Los tipos primitivos incluyen int, double, float (requiere sufijo 'f') y boolean. Las cadenas de texto se manejan con la clase String.

int edad = 25;
double precio = 19.99;
float temperatura = 36.6f;
String nombre = "Juan";
System.out.println("Hola " + nombre);

Estructuras de Control

El flujo se gestiona con if-else y switch. En Java, las llaves {} son fundamentales para delimitar bloques. El switch es ideal para menús, recordando siempre el uso de break y default.

Entrada de Datos e Interacción

Exploramos la entrada gráfica con JOptionPane (requiere parseo) y la entrada por consola con Scanner.

Ciclos e Iteración

Manejamos while (validación previa), do-while (ejecución garantizada de una vez) y el ciclo for. También introducimos el for-each para recorrer colecciones de forma simplificada.

Arreglos y Matrices

Los arreglos en Java son objetos de tamaño fijo instanciados con new. Escalamos hacia matrices bidimensionales y tridimensionales, utilizando ciclos anidados para su recorrido, aunque destacamos que para grandes volúmenes de datos complejos es preferible el uso de bases de datos.

Introducción al Entorno y Estructura Básica

En el estudio del lenguaje Java es fundamental comprender la rigurosidad de su sintaxis en comparación con lenguajes de tipado dinámico como Python. Java requiere la definición explícita de los tipos de datos y el uso estricto de signos de puntuación como el punto y coma (;) al final de cada instrucción. Todo programa en Java debe estar contenido dentro de una clase, cuya nomenclatura por convención utiliza PascalCase. Dentro de esta clase se define el método principal public static void main(String[] args), que actúa como el punto de entrada para la ejecución del programa mediante la Máquina Virtual de Java (JVM).

Manejo de Variables y Tipos de Datos

Es obligatorio declarar el tipo de dato de cada variable antes de utilizarla. Para números enteros se utiliza int, para decimales double o float, cadenas de texto con String y valores de verdad con boolean. La convención para nombrar variables es camelCase.

Entrada y Salida de Datos por Consola

La interacción se realiza mediante System.out.println() para salida y la clase java.util.Scanner para entrada. Es crucial instanciar el objeto Scanner y usar métodos como nextInt() o nextLine() según el tipo esperado.

Estructuras de Control Condicionales

La toma de decisiones se implementa con if, else if y else, delimitando bloques siempre con llaves {}. Utilizamos operadores lógicos como && (AND) para validar rangos o intervalos específicos.

Lógica de Ciclos: Bucle While y For

El ciclo while es ideal para procesos donde no se conoce el número de iteraciones (ej. juegos de adivinanza con pistas altas/bajas), permitiendo el uso de operadores de autoincremento como intentos++. Por su parte, el ciclo for se utiliza cuando el número de repeticiones es conocido, facilitando cálculos iterativos con acumuladores inicializados en cero.

Conceptos Básicos y Estructura de Datos

Un array en Java es una colección homogénea de variables del mismo tipo bajo un mismo nombre. Es fundamental comprender la indexación base cero: el primer elemento se ubica en el índice 0 y el último en longitud - 1. Esta lógica es vital para evitar errores de desbordamiento de memoria.

Declaración e Inicialización de Arreglos

Java diferencia entre declarar la variable y reservar memoria (instanciación). Se utiliza new para definir la capacidad, o llaves {} para inicializar con valores predefinidos.

// Declaración e instanciación
int[] miArray = new int[5];

// Inicialización simultánea
int[] datos = {10, 20, 30, 40, 50};

Recorrido y Ciclos

Utilizamos el ciclo for clásico para control total sobre el índice (usando array.length) y el ciclo for-each para lecturas más limpias y directas.

Algoritmos Estadísticos

Implementamos lógica de comparación secuencial para hallar máximos y mínimos, además de acumuladores para sumatorias y promedios. Para cálculos de promedio es vital el uso de double para evitar truncamientos.

Modularización mediante Métodos

Encapsulamos la lógica en métodos para promover un código limpio y reutilizable. Un método puede recibir arrays y devolver reportes estadísticos estructurados.

El Paradigma POO

La Programación Orientada a Objetos (POO) en Java establece una transición desde la lógica secuencial hacia el modelado de entidades. Este enfoque facilita la modularización y el escalamiento al interactuar entre objetos con características y comportamientos definidos.

Clase vs Objeto

Una clase es una plantilla o esquema general (como un molde de galletas), mientras que un objeto es la instancia específica (la galleta individual) que materializa el molde con datos concretos.

Atributos y Métodos

Los componentes clave son los atributos (características como nombre o edad) y los métodos (acciones como correr o atacar). En la práctica, modelamos clases como SuperPersonaje definiendo estas propiedades fundamentales.

public class SuperPersonaje {
    String nombre;
    int poder;

    void atacar() {
        System.out.println(nombre + " está atacando!");
    }
}

Instanciación y Constructores

Para crear un objeto utilizamos el operador new. Para inicializar atributos al momento de la creación, implementamos el método constructor, que debe ser público y llevar el mismo nombre de la clase, utilizando this para diferenciar parámetros de atributos propios.

Encapsulamiento: Getters y Setters

El encapsulamiento protege la integridad de los datos mediante modificadores private. El acceso controlado se habilita mediante métodos Getters (lectura) y Setters (escritura), permitiendo validar los datos antes de su asignación.

Clases, Objetos y Constructores

La POO en Java se fundamenta en la distinción entre clase (molde o plantilla) y objeto (instancia independiente). El método constructor es vital para inicializar atributos mediante el operador new y la palabra clave this, asegurando que cada objeto nazca con un estado definido.

Encapsulamiento y Protección de Datos

Garantizamos la integridad de los datos definiendo atributos como private. La interacción se realiza mediante Getters y Setters, permitiendo incorporar lógica de validación interna para evitar datos inconsistentes.

Herencia Cósmica: La Clase Object

En Java, todas las clases heredan de la clase Object. Esto nos otorga métodos predefinidos como toString(). Por defecto, este método no es muy útil, por lo que aplicamos la sobreescritura (@Override) para que retorne una representación legible de los atributos del objeto.

Polimorfismo: Sobrecarga y Sobreescritura

Diferenciamos entre Sobreescritura (modificar un método heredado) y Sobrecarga (mismos nombres con firmas/parámetros distintos). La sobrecarga permite que un método sea flexible y responda de forma distinta según los argumentos suministrados.

// Sobrecarga de Constructor
public Producto(String nombre) { ... }
public Producto(String nombre, double precio) { ... }

Fundamentos de UML para Desarrolladores

El Lenguaje Unificado de Modelado (UML) es la herramienta estándar para representar gráficamente la arquitectura de software. Un diagrama de clase se divide en tres secciones: el nombre (superior), los atributos o propiedades (intermedia) y las operaciones o métodos (inferior). Es vital identificar la visibilidad: el símbolo menos (-) indica visibilidad privada (encapsulamiento), mientras que el más (+) indica visibilidad pública.

Modelado de Clases y Atributos

La traducción de requisitos a código requiere definir atributos con tipos específicos (String, double, boolean) y seguir la convención camelCase. En esta sesión modelamos entidades como un SuperPersonaje, una TarjetaSIM (con saldo y empresa) y un Autobus.

Constructores y Referencia global

Implementamos métodos constructores para inicializar el estado del objeto al instanciarlo con new. Utilizamos la palabra clave this para asignar parámetros a los atributos internos, garantizando que el objeto inicie con datos coherentes.

Getters, Setters y Lógica de Negocio

Protegemos los datos mediante métodos Getter (usando is para booleanos como isCelularApagado) y Setter. Además, implementamos la lógica de negocio mediante métodos de comportamiento que realizan cálculos complejos, como el cobro de pasajes según el estrato socioeconómico o la compra de datos con tarifas escalonadas.

Herencia y Reutilización de Código

La herencia permite crear nuevas clases basadas en clases existentes mediante la palabra reservada extends. Al identificar características comunes (nombre, vida, caminar), definimos una superclase (ej. Humano) que las subclases (ej. Guerrero, NPC) heredan automáticamente.

Gestión de Constructores y super()

Al instanciar una subclase, debemos inicializar la superclase utilizando super(). Esto garantiza que los atributos heredados se configuren correctamente antes de añadir lógica específica. Java implementa herencia simple (un solo padre).

Clases Abstractas

Declaramos clases con el modificador abstract para servir como moldes que no pueden instanciarse directamente (ej. new Humano()). Esto obliga a utilizar subclases concretas (Guerrero, Mago), asegurando la coherencia lógica del modelo.

Interfaces y Contratos de Comportamiento

Las interfaces (interface / implements) definen "qué puede hacer" un objeto, independientemente de su jerarquía. Son contratos que obligan a la clase a implementar ciertos métodos (ej. IAsignable para recibir misiones).

public interface IAsignable {
    void asignarMision(String mision);
}

public class Mago extends Humano implements IAsignable { ... }

Flexibilidad con Métodos default

En versiones modernas de Java, las interfaces pueden incluir lógica base mediante métodos default, evitando la repetición de código y permitiendo una especie de herencia múltiple de comportamientos.

Fundamentos del Polimorfismo

El polimorfismo (etimológicamente "muchas formas") es el pilar de la POO que permite que los objetos se comporten de maneras distintas según su contexto o implementación específica. Para aplicarlo, es esencial dominar primero la creación de clases, la herencia (reutilización) y las interfaces (contratos).

Polimorfismo de Métodos: Sobreescritura

Mediante la anotación @Override, una subclase puede redefinir la lógica de un método heredado para ajustarlo a su propia naturaleza. También exploramos los métodos abstractos, donde definimos la existencia de una acción pero obligamos a cada subclase a implementar su propia lógica de ejecución.

Polimorfismo en Estructuras de Datos

Una de las mayores ventajas del polimorfismo es la superación de la rigidez de los tipos de datos en arreglos. Es posible crear arreglos de una superclase o interfaz para almacenar instancias de diferentes subclases, permitiendo iterar sobre colecciones heterogéneas y ejecutar acciones comunes.

// Arreglo polimórfico
Humano[] equipo = new Humano[3];
equipo[0] = new Guerrero("Thor");
equipo[1] = new Mago("Gandalf");

for (Humano h : equipo) {
    h.comer(); // Cada uno come según su implementación
}

Flexibilidad y Escalabilidad

La capacidad de asignar una instancia de una subclase a una variable de tipo superclase otorga una gran flexibilidad al código, facilitando el mantenimiento y la escalabilidad del software al desacoplar la implementación de la referencia.

Interpretación UML y Encapsulamiento

Implementamos una arquitectura robusta basada en un diagrama UML para las entidades Personaje, Jugador y Enemigo. Aplicamos encapsulamiento estricto (visibilidad privada -) para los atributos base como nombre, posición (X, Y), daño y vida; gestionando el acceso mediante Getters y Setters.

Lógica Matemática y Geometría

Utilizamos la librería Math de Java para calcular la distancia euclidiana entre personajes (hipotenusa). Esta lógica es vital para determinar la efectividad del combate en nuestro modelo dinámico.

Jerarquía de Clases: Jugador vs Enemigo

Mediante extends y super(), especializamos las clases hijas. Jugador incorpora mecánicas de inventario (botiquines con curación condicionada), mientras que Enemigo implementa un sistema de evolución dinámica en cascada que incrementa su peligro cuando su vida desciende por debajo de umbrales críticos (30% y 10%).

Sistema de Interacción y Combate

Desarrollamos el método golpear, cuya efectividad depende inversamente de la distancia al objetivo. Implementamos validaciones de seguridad para asegurar que la salud nunca registre valores negativos, garantizando la consistencia del estado del sistema.

Concepto de Clases y Métodos Abstractos

La abstracción permite definir clases base (abstract class) que sirven como moldes lógicos y no pueden ser instanciadas directamente. Dentro de ellas, declaramos métodos abstractos sin cuerpo, cuya implementación es obligatoria en las clases hijas, garantizando un contrato de comportamiento uniforme.

Variante 1: Lógica de Botones

Desarrollamos una clase abstracta Boton con atributos de diseño y un método hacerClick(). Las subclases concretas definen la acción específica al interactuar, como cambiar el texto del botón.

Variante 2: Gestión de Roles y Redirección

A través de la clase Persona y su subclase Estudiante, implementamos lógica para generar URLs dinámicas basadas en el idioma del usuario, demostrando cómo la subclase define el "cómo" se realiza una acción prescrita por el padre.

Variante 3: Sistema de Asientos de Avión

Programamos una lógica compleja de validación para la inclinación de asientos (límites rigurosos de 0 a 135 grados) y menús de pantalla específicos para categorías como Bronce, integrando el uso de super(), this y @Override.

public abstract class Asiento {
    protected int inclinacion;
    public abstract void imprimirMenu();

    public void aumentarInclinacion(int grados) {
        if (this.inclinacion + grados <= 135) {
            this.inclinacion += grados;
        }
    }
}

Fundamentos de Swing y POO

Java Swing es la librería nativa para construir interfaces gráficas (GUI). Bajo el paradigma de la POO, cada ventana o botón es un objeto. Estructuramos las interfaces mediante Contenedores (como JFrame) que actúan como lienzos y Componentes (widgets como JButton o JLabel) con los que el usuario interactúa.

Configuración de Ventanas y Layouts

Instanciamos JFrame para crear la ventana principal, configurando sus dimensiones (setSize) y el cierre de procesos (EXIT_ON_CLOSE). Utilizamos gestores de diseño como BorderLayout para organizar componentes de forma profesional y evitar superposiciones, distribuyéndolos en puntos cardinales y centro.

Interactividad y Manejo de Eventos

Logramos que la interfaz responda mediante Listeners. El ActionListener captura acciones como clics en botones para procesar datos de campos de texto (JTextField) mediante getText o actualizarlos con setText. Para datos sensibles, empleamos JPasswordField con validaciones seguras.

Integración con la Lógica de Negocio

La GUI no es un elemento aislado, sino una capa de visualización que se comunica con nuestros objetos y clases personalizadas. Validamos autenticaciones (usando equals para comparar cadenas) y reflejamos cambios de estado en tiempo real, conectando la experiencia de usuario con la robustez del código backend.

// Crear ventana principal
JFrame ventana = new JFrame("Mi Aplicación");
ventana.setSize(400, 300);
ventana.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
ventana.setVisible(true);