📚 App de Estudio: Programación Java

Temas 1 y 2 - Conceptos Fundamentales

Tu Progreso de Estudio

0%

Bienvenido a tu App de Estudio

📌 ¿Qué vas a aprender?

Esta aplicación te guiará a través de los conceptos fundamentales de la programación en Java, cubriendo:

  • Tema 1: Programación Estructurada - Variables, operadores, casting y comentarios
  • Tema 2: Estructuras de Control - Condicionales, bucles, funciones y recursividad

🎯 Cómo usar esta App

  1. Navega entre los temas usando los botones superiores
  2. Lee cuidadosamente cada sección
  3. Estudia los ejemplos de código en los cajones especiales
  4. Practica copiando y ejecutando el código
  5. Revisa el resumen final para consolidar conocimientos
Programación Estructurada

Diagrama conceptual de programación estructurada

TEMA 1: PROGRAMACIÓN ESTRUCTURADA

💡 Concepto Clave: La programación estructurada es un paradigma que enfatiza la mejora de la claridad, calidad y tiempo de desarrollo de un programa, utilizando estructuras de control de flujo claras y bien definidas.

1.1 Primer programa en Java

Para empezar a programar en Java, necesitamos entender la estructura básica de un programa. Todo programa Java comienza con una clase y un método main.

⚠️ Importante: Las cadenas de texto (String) se delimitan con comillas dobles ("). Se pueden combinar cadenas de texto con números usando el operador + 
// Primer programa en Java: Hola Mundo
public class Main {
  public static void main(String[] args) {
    System.out.println("Hola Mundo!");
  }
}

Ejemplo práctico: Tabla de multiplicar del 4

public class Main {
  public static void main(String[] args) {
    System.out.println("Tabla de Multiplicar del 4");
    System.out.println("--------------------------");
    System.out.println("4x1= " + 4);
    System.out.println("4x2= " + 8);
    System.out.println("4x3= " + 12);
    System.out.println("4x4= " + 16);
    System.out.println("4x5= " + 20);
    System.out.println("4x6= " + 24);
    System.out.println("4x7= " + 28);
    System.out.println("4x8= " + 32);
    System.out.println("4x9= " + 36);
    System.out.println("4x10= " + 40);
  }
}

1.2 Variables

Una variable es un espacio de almacenamiento que se utiliza para almacenar datos que pueden ser modificados durante el uso de un programa.

📋 Características de una variable:

  1. Nombre: identificador único
  2. Tipo de dato: especifica el tipo de valor
  3. Valor: el contenido almacenado
  4. Alcance: contexto donde puede accederse
  5. Duración: tiempo que existe en memoria

🔢 Tipos de datos primitivos en Java:

Valores lógicos:
  • boolean - true o false
Números Enteros:
  • byte - números pequeños
  • int - números enteros
  • long - números enteros grandes
Números Decimales:
  • float - decimales de precisión simple
  • double - decimales de doble precisión
Caracteres:
  • char - un único carácter
Cadenas de texto:
  • String - texto (tipo complejo)
public class Main {
  public static void main(String[] args) {
    // Declaración de variables
    boolean esVerdadero = true;
    byte numeroPequeno = 100;
    int numeroEntero = 100000;
    float numeroDecimal = 10.5f;
    double numeroDoble = 10.5;
    char letra = 'A';
    String texto = "Hola, mundo!";

    // Ejemplo práctico: Temperatura
    String mensaje = "La temperatura máxima en Oviedo es: ";
    double temperatura = 21.5;
    System.out.println(mensaje + temperatura + "ºC");
  }
}

1.3 Operadores

Un operador es un símbolo que indica al ordenador que realice una operación matemática, lógica o de manipulación de datos específica.

➕ 1. OPERADORES ARITMÉTICOS

  • + suma
  • - resta
  • * multiplicación
  • / división
  • % módulo (resto de una división)

🔄 2. OPERADORES UNARIOS

  • ++ incremento (aumenta en 1)
  • -- decremento (disminuye en 1)
  • ! negación lógica

📝 3. OPERADORES DE ASIGNACIÓN

  • = asignación
  • += suma y asignación
  • -= resta y asignación
  • *= multiplicación y asignación
  • /= división y asignación

⚖️ 4. OPERADORES RELACIONALES

  • == igual a
  • != no igual a
  • > mayor que
  • < menor que
  • >= mayor o igual que
  • <= menor o igual que

🔀 5. OPERADORES LÓGICOS

  • && AND lógico
  • || OR lógico
  • ! NOT lógico
public class Main {
  public static void main(String[] args) {
    // Operadores aritméticos
    int a = 10;
    int b = 5;
    int suma = a + b;        // 15
    int resta = a - b;       // 5
    int mult = a * b;        // 50
    int divide = a / b;      // 2
    int modulo = a % b;      // 0

    // Operadores de asignación
    a += 5;  // a = a + 5 = 15
    a -= 3;  // a = a - 3 = 12

    // Operadores relacionales
    boolean mayor = (a > b);     // true
    boolean igual = (a == b);    // false

    // Operadores lógicos
    boolean resultado1 = true && false;  // false
    boolean resultado2 = true || false;  // true
    boolean resultado3 = !true;          // false

    System.out.println("Suma: " + suma);
    System.out.println("Mayor: " + mayor);
  }
}

1.4 Casting

El casting es el proceso de convertir un valor de un tipo de dato a otro.

📊 Tipos de Casting:

1. Casting Implícito (Widening):
  • Conversión automática de tipo menor a mayor
  • Java lo hace automáticamente
  • Ejemplo: int → long, float → double
2. Casting Explícito (Narrowing):
  • Conversión de tipo mayor a menor
  • Debe especificarse manualmente
  • Puede causar pérdida de datos
  • Ejemplo: double → int
public class Main {
  public static void main(String[] args) {
    // CASTING IMPLÍCITO
    int numeroEntero = 100;
    long numeroLargo = numeroEntero;        // Automático
    double numeroDecimal = numeroEntero;    // Automático

    System.out.println("Número entero: " + numeroEntero);
    System.out.println("Número largo: " + numeroLargo);
    System.out.println("Número decimal: " + numeroDecimal);

    // CASTING EXPLÍCITO
    double decimal = 9.78;
    int entero = (int) decimal;  // Manual - pierde decimales

    System.out.println("Número decimal: " + decimal);    // 9.78
    System.out.println("Número entero: " + entero);      // 9
  }
}

1.5 IDE y Comentarios

💻 IDE (Integrated Development Environment)

Un IDE es un entorno de desarrollo integrado que proporciona herramientas completas para desarrollar software.

Componentes de un IDE:
  • Editor de Código Fuente
  • Compilador/Intérprete
  • Depurador (Debugger)
  • Constructor de proyectos
  • Sistema de control de versiones
IDEs populares para Java:
  • Eclipse
  • IntelliJ IDEA
  • NetBeans
  • Visual Studio Code

💬 Comentarios en Java

Los comentarios son fragmentos de texto que el compilador ignora. Sirven para documentar el código.

public class Main {
  public static void main(String[] args) {
    // Comentario de una sola línea
    int numero = 10;  // También puede ir al final

    /* 
     * Comentario de múltiples líneas.
     * Se puede utilizar para describir
     * secciones del código.
     */
    System.out.println(numero);
  }

  /**
   * Suma dos números enteros.
   * @param a El primer número a sumar
   * @param b El segundo número a sumar
   * @return La suma de a y b
   */
  public static int sumar(int a, int b) {
    return a + b;
  }
}
⚠️ Tipos de comentarios:
  • // - Comentario de una línea
  • /* */ - Comentario de múltiples líneas
  • /** */ - Javadoc (documentación)

TEMA 2: ESTRUCTURAS DE CONTROL

💡 Concepto Clave: Las estructuras de control son bloques fundamentales que permiten controlar el flujo de ejecución del programa, decidiendo qué instrucciones se ejecutan y en qué orden.
Estructuras de Control

Visualización de estructuras de control en Java

2.1 Condicionales

Las estructuras condicionales permiten ejecutar diferentes bloques de código dependiendo de si una condición se evalúa como verdadera o falsa.

🔀 Tipos de Estructuras Condicionales:

1. IF Simple: Ejecuta código si la condición es verdadera
2. IF-ELSE: Ejecuta un bloque u otro según la condición
3. IF-ELSE-IF: Evalúa múltiples condiciones secuenciales
4. SWITCH: Selecciona una de muchas ramas de ejecución 
public class Main {
  public static void main(String[] args) {
    // IF simple
    int numero = 10;
    if (numero > 5) {
      System.out.println("El número es mayor que 5");
    }

    // IF-ELSE
    int numero2 = 4;
    if (numero2 > 5) {
      System.out.println("El número es mayor que 5");
    } else {
      System.out.println("El número es menor o igual que 5");
    }

    // IF-ELSE-IF
    int numero3 = 7;
    if (numero3 > 10) {
      System.out.println("El número es mayor que 10");
    } else if (numero3 > 5) {
      System.out.println("Mayor que 5 pero menor o igual a 10");
    } else {
      System.out.println("El número es menor o igual que 5");
    }

    // SWITCH
    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("Día no válido");
        break;
    }
  }
}

2.2 Bucles (Repetición)

Los bucles permiten ejecutar repetidamente un bloque de código mientras se cumple una condición.

🔁 Tipos de Bucles:

1. FOR:
  • Ejecuta un número específico de veces
  • Ideal cuando se conoce el número de iteraciones
2. WHILE:
  • Ejecuta mientras una condición sea verdadera
  • Útil cuando no se sabe cuántas iteraciones serán
3. DO-WHILE:
  • Similar a while pero se ejecuta al menos una vez
  • La condición se evalúa al final
public class Main {
  public static void main(String[] args) {
    // Bucle FOR
    System.out.println("Bucle FOR:");
    for (int i = 0; i < 5; i++) {
      System.out.println("Iteración: " + i);
    }

    // Bucle WHILE
    System.out.println("\nBucle WHILE:");
    int i = 0;
    while (i < 5) {
      System.out.println("Iteración: " + i);
      i++;
    }

    // Bucle DO-WHILE
    System.out.println("\nBucle DO-WHILE:");
    int j = 0;
    do {
      System.out.println("Iteración: " + j);
      j++;
    } while (j < 5);
  }
}
⚠️ Importante: El bucle do-while SIEMPRE se ejecuta al menos una vez, mientras que for y while podrían no ejecutarse si la condición inicial es falsa.

2.3 Estructuras de Salto

Permiten alterar el flujo normal de ejecución de manera abrupta.

⚡ Tipos de Saltos:

BREAK: Sale de un bucle o switch antes de completarse
CONTINUE: Omite la iteración actual y pasa a la siguiente
RETURN: Sale de un método y devuelve un valor 
public class Main {
  public static void main(String[] args) {
    // BREAK - Sale del bucle cuando i es igual a 5
    System.out.println("Ejemplo BREAK:");
    for (int i = 0; i < 10; i++) {
      if (i == 5) {
        break;  // Sale del bucle
      }
      System.out.println("Iteración: " + i);
    }

    // CONTINUE - Omite las iteraciones cuando i es par
    System.out.println("\nEjemplo CONTINUE:");
    for (int i = 0; i < 10; i++) {
      if (i % 2 == 0) {
        continue;  // Salta a la siguiente iteración
      }
      System.out.println("Iteración impar: " + i);
    }

    // RETURN - Devuelve un valor desde un método
    int resultado = sumar(10, 5);
    System.out.println("\nLa suma es: " + resultado);
  }

  public static int sumar(int a, int b) {
    return a + b;  // Devuelve la suma de a y b
  }
}

2.4 Funciones

Una función es un bloque de código reutilizable que realiza una tarea específica.

🎯 Características de una Función:

  1. Nombre: identifica la función de manera única
  2. Parámetros: variables que recibe como entrada
  3. Cuerpo: bloque de código que define qué hace
  4. Valor de retorno: resultado que devuelve (opcional)
Tipos de Funciones:
  • Sin parámetros y sin retorno
  • Con parámetros y con retorno
  • Con parámetros y sin retorno
  • Sin parámetros y con retorno
public class Main {
  public static void main(String[] args) {
    // Llamar función sin parámetros y sin retorno
    imprimirMensaje();

    // Llamar función con parámetros y con retorno
    int resultado = sumar(10, 5);
    System.out.println("La suma es: " + resultado);

    // Llamar función con parámetros y sin retorno
    imprimirSaludo("Carlos");
  }

  // Función sin parámetros y sin retorno
  public static void imprimirMensaje() {
    System.out.println("¡Bienvenido al curso de Java!");
  }

  // Función con parámetros y con retorno
  public static int sumar(int a, int b) {
    return a + b;
  }

  // Función con parámetros y sin retorno
  public static void imprimirSaludo(String nombre) {
    System.out.println("Hola, " + nombre + "!");
  }
}

2.5 Recursividad

La recursividad es una técnica donde una función se llama a sí misma para resolver problemas más pequeños del mismo tipo.

⚠️ Elementos Clave:
  • Caso base: Condición que detiene la recursión
  • Caso recursivo: Llamada a la función misma con problema más pequeño
  • Cada llamada debe acercarse al caso base
  • Sin caso base correcto = desbordamiento de pila (stack overflow)
Ejemplo: Factorial
El factorial de 5 es: 5! = 5 × 4 × 3 × 2 × 1 = 120

Ejemplo: Fibonacci
Sucesión: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55...
Cada término es la suma de los dos anteriores 
public class Main {
  public static void main(String[] args) {
    // Factorial recursivo
    int numero = 5;
    int resultadoFactorial = factorial(numero);
    System.out.println("El factorial de " + numero + " es: " + 
                       resultadoFactorial);

    // Fibonacci recursivo
    int n = 10;
    int resultadoFib = fibonacci(n);
    System.out.println("El término " + n + " de Fibonacci es: " + 
                       resultadoFib);
  }

  // Función recursiva para calcular el factorial
  public static int factorial(int n) {
    if (n == 0) {
      return 1;  // Condición base
    } else {
      return n * factorial(n - 1);  // Llamada recursiva
    }
  }

  // Función recursiva para calcular Fibonacci
  public static int fibonacci(int n) {
    if (n <= 1) {
      return n;  // Condiciones base
    } else {
      return fibonacci(n - 1) + fibonacci(n - 2);  // Llamadas recursivas
    }
  }

  // Versión ITERATIVA del factorial (para comparar)
  public static int factorialIterativo(int n) {
    int resultado = 1;
    for (int i = 1; i <= n; i++) {
      resultado *= i;
    }
    return resultado;
  }
}
💡 Recursividad vs Iteración:
Muchos problemas pueden resolverse tanto de forma recursiva como iterativa. La recursividad es más elegante y cercana a definiciones matemáticas, pero la iteración suele ser más eficiente en memoria.

2.6 Palabras Reservadas

Las palabras reservadas son identificadores predefinidos que tienen un significado especial para el compilador de Java.

📚 Clasificación:

Tipos de datos:
boolean, byte, char, double, float, int, long, short, void

Control de flujo:
if, else, switch, case, default, while, do, for, break, continue, return

Modificadores de acceso:
public, private, protected, static, final, abstract

Clases y objetos:
class, interface, extends, implements, new, this, super

Otras:
import, package, null, instanceof, try, catch, finally, throw, throws
⚠️ Importante: Las palabras reservadas NO pueden usarse como nombres de variables, métodos o clases. Java las reconoce automáticamente y las usa para estructurar el código.

2.7 Pseudocódigo

El pseudocódigo es una descripción de alto nivel de un algoritmo que combina lenguaje natural con estructuras de programación.

🎯 Objetivos del Pseudocódigo:

  • Planificar algoritmos sin preocuparse por la sintaxis
  • Concentrarse en la lógica del problema
  • Facilitar la comunicación entre programadores
  • Servir como puente entre el problema y el código
Estructura General: 
Proceso NombreProceso
    acción 1;
    acción 2;
    ...
    acción n;
FinProceso
Elementos Comunes:
  • ENTRADA / SALIDA
  • SI...ENTONCES...SINO
  • PARA...HASTA...HACER
  • MIENTRAS...HACER
  • DEVOLVER
/*
PSEUDOCÓDIGO - Calcular potencia:

ALGORITMO CalcularPotencia
    ENTRADA: base (entero), exponente (entero)
    SALIDA: resultado (entero)

    SI exponente = 0 ENTONCES
        resultado <- 1
    SINO
        resultado <- 1
        PARA i <- 1 HASTA exponente HACER
            resultado <- resultado * base
        FIN PARA
    FIN SI

    DEVOLVER resultado
FIN ALGORITMO
*/

// CÓDIGO JAVA equivalente:
public class Main {
  public static void main(String[] args) {
    int resultado = potencia(2, 3);
    System.out.println("Resultado: " + resultado);
  }

  public static int potencia(int base, int exponente) {
    if (exponente == 0) {
      return 1;
    } else {
      int resultado = 1;
      for (int i = 1; i <= exponente; i++) {
        resultado *= base;
      }
      return resultado;
    }
  }
}
💡 Ventaja Principal: El pseudocódigo es independiente del lenguaje de programación, lo que permite planificar la solución una vez y luego implementarla en cualquier lenguaje (Java, Python, C++, etc.).

✅ Resumen de Conceptos Clave

📖 Tema 1: Programación Estructurada

1.1 Primer Programa en Java
  • Estructura básica: public class Main { public static void main(String[] args) { } }
  • System.out.println() imprime con salto de línea
  • Las cadenas de texto se delimitan con comillas dobles ("texto")
  • Se pueden combinar textos y números con el operador +
1.2 Variables
  • Son espacios de almacenamiento para datos que pueden modificarse
  • Tienen: nombre, tipo de dato, valor, alcance y duración
  • Tipos primitivos: boolean, byte, int, long, float, double, char
  • Tipo complejo: String (cadenas de texto)
1.3 Operadores
  • Aritméticos: +, -, *, /, % (módulo)
  • Unarios: ++, --, ! (negación)
  • Asignación: =, +=, -=, *=, /=
  • Relacionales: ==, !=, >, <,>=, <=< /li>
  • Lógicos: && (AND), || (OR), ! (NOT)
1.4 Casting
  • Implícito (Widening): conversión automática de menor a mayor tamaño
  • Explícito (Narrowing): conversión manual de mayor a menor (puede perder datos)
  • Ejemplo explícito: int x = (int) 9.78; → resultado: 9
1.5 IDE y Comentarios
  • IDE: Entorno integrado (Eclipse, IntelliJ IDEA, NetBeans)
  • Comentarios:
    • Una línea: // comentario
    • Múltiples líneas: /* comentario */
    • Javadoc: /** documentación */

📖 Tema 2: Estructuras de Control

2.1 Condicionales
  • IF: ejecuta código si condición es verdadera
  • IF-ELSE: ejecuta un bloque u otro según condición
  • IF-ELSE-IF: evalúa múltiples condiciones secuenciales
  • SWITCH: selecciona una rama según valor de expresión
2.2 Bucles
  • FOR: número específico de iteraciones (se conoce de antemano)
  • WHILE: se ejecuta mientras condición sea verdadera
  • DO-WHILE: se ejecuta al menos una vez, luego evalúa condición
2.3 Estructuras de Salto
  • BREAK: sale de un bucle o switch prematuramente
  • CONTINUE: salta a la siguiente iteración del bucle
  • RETURN: sale del método y devuelve un valor (opcional)
2.4 Funciones
  • Bloque de código reutilizable para realizar una tarea específica
  • Características: nombre, parámetros, cuerpo, valor de retorno
  • Permiten modularidad y reutilización del código
  • Sintaxis: public static tipoRetorno nombre(parametros) { }
2.5 Recursividad
  • Técnica donde una función se llama a sí misma
  • Requiere caso base (detiene recursión) y caso recursivo
  • Útil para problemas jerárquicos (árboles, grafos)
  • Ejemplos clásicos: factorial, Fibonacci
  • Mayor consumo de memoria que soluciones iterativas
2.6 Palabras Reservadas
  • Identificadores con significado especial para el compilador
  • NO pueden usarse como nombres de variables, métodos o clases
  • Categorías: tipos de datos, control de flujo, modificadores, clases/objetos
  • Ejemplos: if, else, for, while, class, public, void, return
2.7 Pseudocódigo
  • Descripción de alto nivel de un algoritmo
  • Combina lenguaje natural con estructuras de programación
  • Independiente del lenguaje de programación
  • Permite planificar la lógica antes de codificar
  • Facilita comunicación entre programadores

🎯 Puntos Clave para Recordar

Fundamentos de Java:
  • Todo programa Java comienza con una clase y el método main
  • Java es un lenguaje fuertemente tipado (debes declarar tipos de variables)
  • Usa punto y coma (;) para terminar instrucciones
  • Las llaves { } delimitan bloques de código
Buenas Prácticas:
  • Usa nombres descriptivos para variables y funciones
  • Comenta tu código para facilitar su comprensión
  • Indenta correctamente para mejorar legibilidad
  • Evita código duplicado usando funciones
  • Prueba tu código con diferentes casos de entrada
Errores Comunes a Evitar:
  • Olvidar el punto y coma al final de las instrucciones
  • No cerrar llaves, paréntesis o comillas
  • Confundir = (asignación) con == (comparación)
  • División por cero en operaciones aritméticas
  • Bucles infinitos por condiciones incorrectas
  • No tener caso base en funciones recursivas

🚀 Siguientes Pasos

  1. Repasa cada sección de los temas 1 y 2
  2. Practica escribiendo los ejemplos de código
  3. Modifica los ejemplos para experimentar
  4. Intenta resolver ejercicios similares por tu cuenta
  5. Usa un IDE para compilar y ejecutar tus programas
  6. Consulta la documentación oficial de Java cuando tengas dudas

🎓 App de Estudio - Programación Java

Temas 1 y 2: Programación Estructurada y Estructuras de Control

Desarrollado por Benja

GitHub: benriosdev

© 2025 - Creado para facilitar el aprendizaje de Java / iLERNA DAW