Java Fundamentals: De lo Visual a Código

Módulo 1: Introducción a Alice 3

Alice 3 es un innovador entorno de programación basado en bloques que te permite crear animaciones 3D, contar historias interactivas y construir juegos simples. Su objetivo principal es enseñar conceptos de programación, especialmente la Programación Orientada a Objetos (POO), de una manera visual y atractiva, eliminando la barrera de la sintaxis compleja.

Características Destacadas de Alice 3:

• Entorno 3D Interactivo: Cuentas con una galería rica en modelos 3D (personas, animales, vehículos, edificios) que puedes agregar a tu escena. Puedes manipular sus propiedades (color, tamaño, posición) y hacerlos interactuar.
• Programación Orientada a Objetos (POO) Visual:
  • Objetos: Cada elemento en tu escena es un objeto. Por ejemplo, un `Dragon` es un objeto.
  • Clases: Los objetos se crean a partir de "planos" o plantillas llamadas clases. Alice proporciona clases como `Biped` (para humanoides), `Flyer` (para objetos voladores), `Quadruped` (para animales de cuatro patas). Puedes ver la jerarquía de clases y cómo un `Dragon` podría ser un `Flyer`.
  • Métodos (Procedimientos y Funciones): Son las acciones que los objetos pueden realizar (ej: `dragon.moveForward(1)`), o las preguntas que puedes hacer sobre ellos (ej: `dragon.distanceTo(princesa)`). En Alice, defines estos métodos arrastrando bloques de acción.
  • Propiedades: Atributos de los objetos que puedes cambiar (ej: `dragon.setPaint(Color.RED)`).
• Estructuras de Control Visuales: Conceptos como bucles (`count`, `while`), condicionales (`if/else`) y eventos (when mouse clicks on object) se representan con bloques específicos que estructuran tu código.
• Narración de Historias y Creación de Juegos: Alice fomenta la creatividad al permitirte diseñar escenarios y coreografiar las acciones de tus personajes para contar una historia o crear las mecánicas de un juego simple.
• Puente hacia Java (Alice to Java Mode): Una característica clave es la capacidad de ver una representación en código Java del programa que has creado con bloques. Esto ayuda a los estudiantes a familiarizarse con la sintaxis de Java gradualmente.

// Bloque de Alice:
// HACER EN ORDEN
//   personaje.mover(ADELANTE, 1 metro)
//   personaje.decir("¡Hola Mundo!")
                            

// Código Java correspondiente:
// (Dentro de un método en una clase de personaje)
this.move(Direction.FORWARD, 1.0);
this.say("¡Hola Mundo!");
                            

Beneficios de Aprender con Alice 3:

• Aprendizaje Intuitivo: Reduce la frustración inicial con la sintaxis, permitiendo enfocarse en la lógica y el diseño algorítmico.
• Motivación y Compromiso: La creación de animaciones y juegos 3D es inherentemente atractiva.
• Desarrollo del Pensamiento Computacional: Fomenta la descomposición de problemas, el reconocimiento de patrones y el diseño de algoritmos.
• Sólida Base para POO: Introduce de forma tangible los conceptos de objetos, clases, métodos y propiedades.

Alice 3 es una excelente herramienta para dar tus primeros pasos en la programación antes de sumergirte en lenguajes basados en texto como Java.

Módulo 2: Explorando con Greenfoot

Greenfoot es un entorno de desarrollo integrado (IDE) diseñado para facilitar el aprendizaje de la programación en Java, especialmente para principiantes, a través de la creación de juegos 2D y simulaciones interactivas. Combina la programación visual con la escritura de código Java real, sirviendo como un excelente puente entre entornos puramente basados en bloques (como Alice) y los IDEs profesionales de Java.

Características Clave de Greenfoot:

• Programación Directa en Java: A diferencia de Alice, en Greenfoot escribes código Java estándar, pero con el apoyo de una API simplificada y un entorno visual.
• Entorno Interactivo: Puedes colocar actores en el mundo manualmente, inspeccionar sus estados e invocar sus métodos directamente desde la interfaz para probarlos.
• Ciclo de Actuación (act()): El corazón de la mayoría de los actores es el método public void act(). Este método es llamado repetidamente por Greenfoot cuando el escenario está "corriendo", permitiendo que los actores realicen acciones y reaccionen a su entorno en cada "paso" de la simulación.
• API de Greenfoot: Proporciona clases y métodos útiles para tareas comunes en juegos y simulaciones:
  • Movimiento: move(int distance), turn(int angle), setLocation(int x, int y).
  • Detección de Teclas: Greenfoot.isKeyDown(String keyName).
  • Interacción con Objetos: isTouching(Class clss), getOneObjectAtOffset(int dx, int dy, Class clss), removeTouching(Class clss).
  • Sonido: Greenfoot.playSound(String soundFile).
  • Control del Mundo: getWorld(), addObject(Actor actor, int x, int y), removeObject(Actor actor).
• Visualización Inmediata: Los cambios en el código se reflejan rápidamente en el comportamiento visual de los actores en el mundo.

Ejemplo Práctico: Un Actor que se Mueve

Creemos un actor simple llamado Caminante que se mueve de izquierda a derecha.

import greenfoot.*;  // Importa las clases necesarias de Greenfoot

public class Caminante extends Actor {
    private int velocidad = 2; // Pixeles que se moverá por acto

    /**
     * El método act se ejecuta cuando se presiona el botón Act o Run.
     * Aquí es donde definimos el comportamiento principal del Caminante.
     */
    public void act() {
        move(velocidad); // Se mueve hacia adelante (según su rotación actual)
        
        // Si llega al borde del mundo, da la vuelta
        if (isAtEdge()) {
            turn(180); // Gira 180 grados
        }
        
        // Ejemplo de interacción con teclas (opcional)
        if (Greenfoot.isKeyDown("space")) {
            // Si se presiona espacio, podría saltar o hacer otra acción
            // Por ahora, solo giramos un poco
            turn(5); 
        }
    }
}
                            

import greenfoot.*;

public class MiMundo extends World {
    public MiMundo() {    
        super(600, 400, 1); // Crea un mundo de 600x400 celdas con tamaño de celda 1x1 pixels.
        prepararMundo();
    }

    private void prepararMundo() {
        Caminante miCaminante = new Caminante();
        addObject(miCaminante, 50, 200); // Añade el caminante en la posición (50, 200)
        
        Caminante otroCaminante = new Caminante();
        addObject(otroCaminante, 50, 100);
        otroCaminante.turn(90); // Lo hacemos mirar hacia abajo
    }
}
                            

Beneficios de Greenfoot:

• Introducción Amigable a Java: Permite escribir código Java real en un contexto visual y menos abstracto.
• Aprendizaje de POO: Conceptos como clases, objetos, herencia (extends Actor) y polimorfismo se vuelven prácticos.
• Desarrollo de Habilidades en Diseño de Juegos/Simulaciones: Lógica de juego, manejo de eventos, interacciones entre objetos.
• Comunidad y Escenarios: Existe una galería de escenarios y proyectos compartidos por la comunidad que pueden ser estudiados y modificados.

import greenfoot.*;
import java.awt.Color;

public class Caminante extends Actor {
    private int velocidad = 2;
    private java.util.Random random = new java.util.Random();
    
    public void act() {
        move(velocidad);
        
        if (isAtEdge()) {
            turn(180);
            cambiarColorAleatorio();
        }
        
        if (Greenfoot.isKeyDown("space")) {
            turn(5);
        }
    }
    
    private void cambiarColorAleatorio() {
        GreenfootImage imagen = getImage();
        
        // Genera colores RGB aleatorios
        int rojo = random.nextInt(256);
        int verde = random.nextInt(256);
        int azul = random.nextInt(256);
        
        // Cambia el color de la imagen
        imagen.setColor(new Color(rojo, verde, azul));
        imagen.fill();
    }
}
                            

Módulo 3: Conceptos Fundamentales de Java y Estructura de un Programa

Una vez familiarizados con la lógica de programación a través de entornos visuales, es hora de sumergirnos en Java, uno de los lenguajes de programación más robustos, versátiles y demandados en el mundo del desarrollo de software.

¿Qué es Java?

Java es un lenguaje de programación de alto nivel, orientado a objetos, concurrente y fuertemente tipado, desarrollado originalmente por Sun Microsystems (ahora Oracle). Su lema "Write Once, Run Anywhere" (WORA - Escribe una vez, ejecuta en cualquier lugar) se refiere a su capacidad de ejecutar código compilado en cualquier plataforma que tenga una Máquina Virtual de Java (JVM) instalada.

Aplicaciones Comunes:

• Desarrollo de aplicaciones empresariales a gran escala.
• Aplicaciones móviles para Android.
• Aplicaciones web del lado del servidor (Servlets, JSPs, Spring Framework).
• Herramientas de Big Data (como Hadoop).
• Sistemas embebidos y dispositivos IoT.

Entorno de Desarrollo Java (JDK, JRE, IDE)

• JDK (Java Development Kit): Esencial para desarrolladores. Incluye el compilador (javac), la JVM, bibliotecas estándar y otras herramientas.
• JRE (Java Runtime Environment): Necesario para *ejecutar* aplicaciones Java. Incluye la JVM y bibliotecas, pero no herramientas de desarrollo.
• IDE (Integrated Development Environment): Entornos como IntelliJ IDEA, Eclipse o VS Code con extensiones para Java facilitan la escritura, compilación, depuración y gestión de proyectos Java.

Estructura Básica de un Programa en Java

Todo programa en Java se organiza dentro de clases. El punto de entrada para la ejecución es el método main.

// Nombre del archivo: HolaMundo.java
package com.moridevedu.ejemplos; // Opcional: define un paquete

import java.util.Date; // Opcional: importa clases de otros paquetes

/**
 * Esta es una clase de ejemplo para demostrar la estructura básica.
 * El nombre de la clase pública debe coincidir con el nombre del archivo.
 */
public class HolaMundo {

    /**
     * El método main es el punto de entrada de la aplicación Java.
     * @param args Argumentos pasados desde la línea de comandos (un array de Strings).
     */
    public static void main(String[] args) {
        // Esta es una sentencia. Termina con punto y coma.
        System.out.println("¡Hola, Mundo Java desde MoriDevEdu!"); 
        
        Date fechaActual = new Date(); // Creando un objeto de la clase Date
        System.out.println("La fecha y hora actual es: " + fechaActual.toString());
    } // Fin del método main
} // Fin de la clase HolaMundo
                    

Conceptos Clave Iniciales en Java:

1. Variables y Tipos de Datos Primitivos

Una variable es un contenedor que almacena un valor. En Java, debes declarar el tipo de dato de una variable antes de usarla.

2. Operadores

Java soporta diversos operadores:

• Aritméticos: +, -, *, / (división), % (módulo/resto).
• Asignación: =, +=, -=, *=, /=, %=.
• Incremento/Decremento: ++ (incrementar en 1), -- (decrementar en 1). Pueden ser prefijos (++a) o postfijos (a++).
• Relacionales (Comparación): == (igual a), != (no igual a), >, <, >=, <=. Devuelven boolean.
• Lógicos: && (Y lógico), || (O lógico), ! (NO lógico).
• Operador Ternario: condicion ? valorSiVerdadero : valorSiFalso;

3. Estructuras de Control de Flujo

Dirigen el orden en que se ejecutan las sentencias.

int edad = 18;
if (edad >= 18) {
    System.out.println("Es mayor de edad.");
} else if (edad > 0 && edad < 18) {
    System.out.println("Es menor de edad.");
} else {
    System.out.println("Edad no válida.");
}
                                    

for (int i = 0; i < 5; i++) {
    System.out.println("Iteración: " + i);
}
                                    

4. Métodos

Bloques de código reutilizables que realizan una tarea específica. Pueden recibir parámetros y devolver un valor.

public class Calculadora {
    // Método que no devuelve valor (void) y recibe dos parámetros enteros
    public static void sumar(int num1, int num2) {
        int resultado = num1 + num2;
        System.out.println(num1 + " + " + num2 + " = " + resultado);
    }

    // Método que devuelve un valor (double) y recibe un parámetro
    public static double calcularAreaCirculo(double radio) {
        if (radio < 0) {
            return 0.0; // Manejo de valor inválido
        }
        return Math.PI * radio * radio;
    }

    public static void main(String[] args) {
        // Llamamos al método sumar
        sumar(10, 5);
        
        // Llamamos al método calcularAreaCirculo y guardamos su resultado
        double area = calcularAreaCirculo(3.5);
        System.out.println("Área del círculo: " + area);
        
        // Probemos con un valor inválido
        double areaInvalida = calcularAreaCirculo(-2);
        System.out.println("Área con radio negativo: " + areaInvalida);
    }
}
                                

public class MiniCalculadora {
    
    // Método para sumar dos números
    public static double sumar(double a, double b) {
        return a + b;
    }
    
    // Método para restar dos números
    public static double restar(double a, double b) {
        return a - b;
    }
    
    // Método para multiplicar dos números
    public static double multiplicar(double a, double b) {
        return a * b;
    }
    
    // Método para dividir dos números
    public static double dividir(double a, double b) {
        if (b == 0) {
            System.err.println("Error: No se puede dividir por cero.");
            return Double.NaN; // Not a Number
        }
        return a / b;
    }
    
    public static void main(String[] args) {
        // Probamos cada método
        double num1 = 10.5;
        double num2 = 5.0;
        double num3 = 0.0;
        
        System.out.println("Operaciones con " + num1 + " y " + num2 + ":");
        System.out.println("Suma: " + sumar(num1, num2));
        System.out.println("Resta: " + restar(num1, num2));
        System.out.println("Multiplicación: " + multiplicar(num1, num2));
        System.out.println("División: " + dividir(num1, num2));
        
        // Probamos división por cero
        System.out.println("\nOperación con " + num1 + " y " + num3 + ":");
        System.out.println("División por cero: " + dividir(num1, num3));
    }
}
                            

Módulo 4: Arrays (Matrices), Excepciones y Profundización en Clases y Objetos

Este módulo expande nuestros conocimientos sobre cómo agrupar datos con arrays, cómo manejar errores de forma robusta con excepciones, y cómo la Programación Orientada a Objetos (POO) se materializa en Java a través de clases y objetos.

Arrays (Matrices) en Java

Un array es una estructura de datos que almacena una colección de tamaño fijo de elementos del mismo tipo. Los elementos se acceden mediante un índice numérico (empezando en 0).

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

Recorriendo Arrays:

// Usando un bucle for tradicional
System.out.println("Nombres:");
for (int i = 0; i < nombres.length; i++) {
    nombres[i] = "Nombre " + (i + 1); // Asignar valores
    System.out.println(nombres[i]);
}
                            

// Usando un bucle for-each - para leer elementos
System.out.println("\nCalificaciones (for-each):");
for (double calif : calificaciones) { 
    // "por cada double calif en calificaciones"
    System.out.println(calif);
}
                            

Arrays Multidimensionales:

Arrays de arrays, comúnmente usados para representar matrices o tablas.

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

Excepciones en Java (Manejo de Errores)

Las excepciones son eventos anómalos que ocurren durante la ejecución de un programa y que interrumpen el flujo normal. Java proporciona un robusto mecanismo para manejarlas.

Bloque try-catch-finally:

try {
    int[] numeros = {1, 2, 3};
    System.out.println("Intentando acceder al elemento en índice " + indice);
    int valor = numeros[indice]; // Puede lanzar ArrayIndexOutOfBoundsException
    System.out.println("Valor obtenido: " + valor);
    
    int resultado = 10 / divisor; // Puede lanzar ArithmeticException
    System.out.println("Resultado de división: " + resultado);
    
} catch (ArrayIndexOutOfBoundsException e) {
    System.err.println("Error: Índice fuera de los límites del array");
    System.err.println("Detalle: " + e.getMessage());
} catch (ArithmeticException e) {
    System.err.println("Error: División por cero no permitida");
    System.err.println("Detalle: " + e.getMessage());
} finally {
    System.out.println("Bloque 'finally' ejecutado. Limpieza finalizada.");
}
                                

Cláusula throws: Un método puede declarar que *puede* lanzar ciertas excepciones verificadas, delegando su manejo al código que lo llama.

import java.io.IOException;
import java.io.FileReader;

public class LectorArchivo {
    // Este método declara que puede lanzar una IOException
    public static void leerPrimerCaracter(String nombreArchivo) throws IOException {
        FileReader fr = null;
        try {
            fr = new FileReader(nombreArchivo);
            System.out.println("Primer caracter: " + (char)fr.read());
        } finally {
            if (fr != null) fr.close(); // Asegura cerrar el archivo
        }
    }

    public static void main(String[] args) {
        try {
            leerPrimerCaracter("miarchivo.txt");
        } catch (IOException e) {
            System.err.println("Error al leer el archivo: " + e.getMessage());
        }
    }
}
                    

Clases y Objetos: Fundamentos de POO en Java

Java es intrínsecamente orientado a objetos. El código se organiza en clases, que son plantillas para crear objetos.

Definición de una Clase:

Una clase define el estado (campos o atributos) y el comportamiento (métodos) de los objetos que se crearán a partir de ella.

// Archivo: Producto.java
public class Producto {
    // Campos (estado del objeto) - Variables de instancia
    String codigo;
    String nombre;
    double precio;
    int stock;

    // Constructor: Método especial para inicializar un objeto cuando se crea.
    // Tiene el mismo nombre que la clase y no tiene tipo de retorno.
    public Producto(String codigo, String nombre, double precio, int stockInicial) {
        // 'this' se refiere a la instancia actual del objeto
        this.codigo = codigo;
        this.nombre = nombre;
        this.precio = precio;
        this.stock = stockInicial;
        System.out.println("Producto '" + this.nombre + "' creado.");
    }
    
    // Otro constructor (sobrecargado) con valores por defecto
    public Producto(String codigo, String nombre, double precio) {
        this(codigo, nombre, precio, 0); // Llama al otro constructor usando 'this()'
    }

    // Métodos (comportamiento del objeto) - Métodos de instancia
    public void mostrarInformacion() {
        System.out.println("--- Información del Producto ---");
        System.out.println("Código: " + this.codigo);
        System.out.println("Nombre: " + this.nombre);
        System.out.println("Precio: $" + this.precio);
        System.out.println("Stock: " + this.stock + " unidades");
    }

    public void agregarStock(int cantidad) {
        if (cantidad > 0) {
            this.stock += cantidad;
            System.out.println(cantidad + " unidades agregadas al stock de " + this.nombre);
        } else {
            System.out.println("La cantidad a agregar debe ser positiva.");
        }
    }

    public boolean vender(int cantidad) {
        if (cantidad > 0 && cantidad <= this.stock) {
            this.stock -= cantidad;
            System.out.println("Venta realizada: " + cantidad + " unidades de " + this.nombre);
            return true;
        } else {
            System.out.println("No se pudo realizar la venta. Stock insuficiente o cantidad inválida.");
            return false;
        }
    }

    // Método getter para el precio (Encapsulación)
    public double getPrecio() {
        return this.precio;
    }

    // Método setter para el precio (Encapsulación)
    public void setPrecio(double nuevoPrecio) {
        if (nuevoPrecio > 0) {
            this.precio = nuevoPrecio;
        } else {
            System.out.println("El precio debe ser positivo.");
        }
    }
}
                    

Creación y Uso de Objetos:

Encapsulación: Es uno de los pilares de la POO. Consiste en ocultar el estado interno de un objeto y exponer solo las operaciones necesarias a través de métodos públicos (getters y setters son comunes para controlar el acceso a los campos privados).

Palabra clave this: Dentro de una clase, this se refiere a la instancia actual del objeto. Se usa para desambiguar entre campos de instancia y parámetros con el mismo nombre, o para llamar a otro constructor de la misma clase (this(...)).

Miembros Estáticos (static): Los campos y métodos declarados como `static` pertenecen a la clase en sí, no a una instancia particular. Se accede a ellos usando el nombre de la clase (ej: `Math.PI`, `Integer.parseInt()`). El método `main` es siempre `static`.