Saltar a contenido

S1 - Algoritmos y Datos

1. Introducción

Tiempo: 1h 30min (40 min de contexto y propósito + 50 min de presentación del curso y del sílabo).

1.1 Presentación de la sesión

Antes de cualquier clase, endpoint o base de datos, un programa es solo esto: datos que entran, se transforman y salen — y hace falta representarlos con el tipo correcto. Esta sesión instala el entorno (Java 21), confirma que el ciclo escribir-compilar-ejecutar funciona, y construye las primeras fichas de datos con el modelo Entrada-Proceso-Salida.

Al ser la primera sesión del curso, no hay trabajo de una sesión anterior que revisar; en su lugar, los 50 min adicionales de esta sección se usan para la presentación del curso y del sílabo (docente, evaluación, cronograma de unidades, Proyecto Sello como cierre del semestre). Desde S2, este mismo bloque de tiempo se dedica a revisar el trabajo autónomo de la sesión anterior.

1.2 Índice

  1. Algoritmos y su estructura básica.
  2. Representación de algoritmos: lenguaje natural, pseudocódigo, diagrama de flujo.
  3. Datos, tipos de datos y variables en Java.
  4. Constantes y metodología para resolver problemas.

1.3 Propósito de aprendizaje

Al concluir la clase, estarás en condiciones de:

  • Representar y desarrollar algoritmos básicos que capturen, procesen y muestren datos, usando el modelo Entrada-Proceso-Salida, variables y tipos de datos correctos en Java 21.

1.4 Producto de sesión

Programa Java ejecutable que captura, procesa y muestra los datos estructurados de una entidad inicial (postulante o producto), usando variables con nombres y tipos adecuados, y una segunda versión con datos ingresados por teclado.

1.5 Metodología

Tabla 1. Metodología de la sesión

Actividades a Realizar en el Periodo Orientaciones generales (Orientaciones Metodológicas) Material de estudio recomendado
Revisión previa individual Instalar y verificar Java 21 LTS. Trabajo individual, antes de clase; traer evidencia de java --version funcionando. Guía de instalación Java 21 (3.1).
Clase presencial Explicación guiada de conceptos (algoritmo, EPS, tipos de datos, variables) y desarrollo de los tres ejercicios guiados. Trabajo individual en la propia laptop, siguiendo al docente paso a paso; consulta inmediata ante errores de compilación. Enunciados de los ejercicios, editor de código, terminal.
Evaluación formativa Verificación en clase de la compilación y ejecución de los tres programas; inicio de la evidencia individual. La evidencia se completa y sustenta de forma individual, fuera del aula, según los criterios mínimos de la sección 4.4. Indicaciones de entrega (4.3), rúbrica de evaluación (4.6).

1.6 Motivación de la sesión

1.6.1 Caso: la primera ficha de un dato real

Cualquier programa que gestione información real —una persona, un producto, un préstamo— necesita antes que nada representar correctamente un solo dato: qué variables necesita, de qué tipo es cada una, y cómo se captura, procesa y muestra. Hoy construimos la ficha más simple posible de un dato del mundo real, con variables y tipos correctos.

Preguntas de análisis

Activación de conocimientos previos

  1. ¿Qué otro dato del mundo real, además de un postulante o un producto, podrías representar con variables?
  2. ¿Por qué un programa necesita distinguir entre texto, número entero y número decimal?

Comprensión de tipos de datos

  1. ¿Qué diferencia hay entre escribir un valor directo en el código y pedirlo por teclado?
  2. ¿Qué pasa si intentas sumar un número que en realidad quedó guardado como texto?

1.7 Ubicación en el curso

  • Unidad: U1 - Estructuras secuenciales y condicionales.
  • Producto de unidad: Portafolio de Soluciones Algorítmicas: de la secuencia a la toma de decisiones.
  • Producto del curso: Proyecto Sello - solución CLI funcional para un problema real y acotado (Unidad III).
  • Avance del producto en esta sesión: primeras fichas de datos con variables y tipos correctos; base conceptual para todo el portafolio.

Roadmap del producto de la unidad:

Figura 1. Roadmap del producto de la unidad

flowchart TB
    S1["S1<br/>Algoritmos, EPS,<br/>variables y tipos"]
    S2["S2<br/>Programación<br/>secuencial"]
    S3["S3<br/>Programación<br/>condicional"]
    S4["S4<br/>Funciones y TDD"]
    S5["S5<br/>Evaluación U1"]

    S1 --> S2 --> S3 --> S4 --> S5

    classDef today fill:#ffe08a,stroke:#9a6b00,stroke-width:2px,color:#111;
    class S1 today;

2. Explica

Tiempo: 50 min.

2.1 Algoritmos

Un algoritmo es un conjunto ordenado y finito de pasos que permite resolver un problema.

Características:

  • Preciso: cada instrucción debe ser clara.
  • Definido: con la misma entrada produce el mismo resultado.
  • Finito: termina después de una cantidad limitada de pasos.
  • Ordenado: sigue una secuencia lógica.

Error frecuente: escribir pasos ambiguos ("procesar los datos") en vez de instrucciones concretas y verificables ("sumar numero1 y numero2").

2.2 Estructura básica: Entrada-Proceso-Salida

Todo algoritmo organiza la solución en tres partes:

Figura 2. Estructura Entrada-Proceso-Salida de un algoritmo

flowchart LR
    E[/Entrada/] --> P[Proceso] --> S[/Salida/]
  • Entrada: datos que recibe (escritos en el código o ingresados por teclado).
  • Proceso: operaciones o transformaciones que realiza.
  • Salida: resultado que muestra.

La Entrada tiene dos formas concretas en un programa: un valor escrito directamente en el código (queda fijo cada vez que se ejecuta) o un valor pedido al usuario durante la ejecución (cambia en cada corrida). Para pedir datos por teclado se usa la clase Scanner de la librería estándar (se ve en la práctica, sección 3.4). El Ejercicio 1 (3.5) trabaja con la primera forma; los Ejercicios 2 y 3 (3.6, 3.7), con la segunda.

2.3 Representación de algoritmos

Representar un algoritmo ayuda a ordenar la solución antes de programarla.

Lenguaje natural:

  1. Leer dos números.
  2. Sumar los números.
  3. Mostrar el resultado.

Pseudocódigo:

Inicio
Leer numero1
Leer numero2
suma <- numero1 + numero2
Escribir suma
Fin

Diagrama de flujo:

Figura 3. Diagrama de flujo para sumar dos números

flowchart TD
inicio([Inicio]) --> entrada[/Leer dos numeros/]
entrada --> proceso[Sumar los numeros]
proceso --> salida[/Mostrar la suma/]
salida --> fin([Fin])

Error frecuente: saltar directo al código sin pasar por pseudocódigo — dificulta detectar errores de lógica antes de escribir Java.

2.4 Datos y tipos de datos en Java

Un dato es una representación de información que puede almacenarse y procesarse. En Java, el tipo se declara explícitamente y el compilador lo verifica antes de ejecutar el programa.

Tabla 2. Tipos de datos primitivos en Java

Dato Tipo Java Ejemplos
Entero int 5, -10, 200
Real (decimal) double 3.14, 25.8, -7.5
Carácter char 'A', '7', '#'
Cadena String "Carlos", "Lima"
Lógico o booleano boolean true, false

Criterio de uso: se elige el tipo según la información — int para cantidades enteras, double para montos o promedios, String para texto, boolean para condiciones.

Error frecuente: declarar todo como String (incluidos números) — impide operar aritméticamente sin convertir, y oculta errores que el compilador detectaría con el tipo correcto.

2.5 Variables y constantes

Una variable es un espacio de memoria identificado por un nombre, con un tipo fijo y un valor que puede cambiar. En Java se declara con el tipo antes del nombre:

int edad;
double sueldo;
String nombre;

edad = 20;
sueldo = 1500.50;
nombre = "Juan";

O declarando y asignando en un solo paso:

int edad = 20;
double sueldo = 1500.50;
String nombre = "Juan";

Reglas para nombrar variables: son adecuados nombres como edad, promedio, totalVentas y notaFinal (convención camelCase en Java: la primera palabra en minúscula y cada palabra siguiente inicia en mayúscula, sin espacios ni guiones). No son adecuados 1edad, total ventas ni @numero.

Una constante es un valor que no debe cambiar durante la ejecución. En Java se declara con final, y por convención su nombre va en mayúsculas:

final double PI = 3.1416;
final String INSTITUCION = "Universidad Peruana Unión";

Error frecuente: reasignar una variable declarada final — el compilador lo rechaza; si un valor cambia durante la ejecución, no debe ser final.

2.6 Metodología para resolver problemas

  1. Comprender el problema: ¿qué se pide?
  2. Identificar entradas: ¿qué datos necesito?
  3. Diseñar el proceso: ¿qué operaciones o decisiones realizaré?
  4. Definir salidas: ¿qué debe mostrar el programa?
  5. Diseñar pruebas: ¿con qué casos comprobaré que funciona?
  6. Escribir, compilar, ejecutar y corregir el código.

En cada ejercicio de este curso se aplican estos pasos antes de programar.

3. Aplica: actividad práctica guiada

Tiempo: 3h 20min (4 horas académicas de 50 min, en laboratorio).

Actividad: construcción guiada de fichas de datos (postulante, producto, código de postulante) con variables, constantes y entrada por teclado en Java.

Propósito de la actividad: aplicar el modelo Entrada-Proceso-Salida para declarar variables y constantes con el tipo correcto, y convertir datos ingresados por teclado antes de operarlos, verificando la compilación y ejecución de cada ejercicio.

Orientaciones metodológicas: en el laboratorio, el docente guía la instalación del entorno y la compilación del primer programa, seguida de los tres ejercicios (ficha de postulante, ficha de producto con Scanner, y código de postulante con formato exacto) paso a paso frente a la clase; los estudiantes replican cada paso en su propio equipo, verificando la compilación y la ejecución antes de avanzar al siguiente.

Actividades para realizar:

  • 3.1 Instalar y verificar Java 21 LTS.
  • 3.2 Instalar VS Code (editor recomendado).
  • 3.3 Compilar y ejecutar el primer programa.
  • 3.4 Leer datos por teclado con Scanner.
  • 3.5 Ejercicio 1: ficha de postulante con variables.
  • 3.6 Ejercicio 2: ficha de producto con datos por teclado.
  • 3.7 Ejercicio 3: código de postulante con formato exacto.

3.1 Instalar y verificar Java 21 LTS

Producto del paso: entorno de desarrollo configurado con Java 21.

Se recomienda Eclipse Temurin 21, una distribución OpenJDK de soporte prolongado, instalada con el gestor de paquetes nativo de cada sistema operativo (evita instaladores manuales y mantiene el JDK actualizable).

Windows — PowerShell como usuario normal:

winget install --id EclipseAdoptium.Temurin.21.JDK --exact

macOS (Homebrew no viene preinstalado en ningún Mac; una vez instalado, el comando de Temurin es el mismo para Intel y para Apple Silicon M1/M2/M3/M4 — Homebrew detecta la arquitectura automáticamente):

# 1. Instalar Homebrew (si no lo tiene)
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

# 2. Solo en Apple Silicon (M1/M2/M3/M4): agregar Homebrew al PATH.
#    Se instala en /opt/homebrew (no en /usr/local como en Intel), y el
#    propio instalador lo pide como paso obligatorio, no opcional.
echo 'eval "$(/opt/homebrew/bin/brew shellenv)"' >> ~/.zprofile
eval "$(/opt/homebrew/bin/brew shellenv)"

# 3. Instalar Temurin 21
brew install --cask temurin@21

Linux (Ubuntu/Debian) — repositorio oficial de Adoptium vía apt:

sudo apt install -y wget apt-transport-https gpg
wget -qO - https://packages.adoptium.net/artifactory/api/gpg/key/public | gpg --dearmor | sudo tee /etc/apt/trusted.gpg.d/adoptium.gpg > /dev/null
echo "deb https://packages.adoptium.net/artifactory/deb $(awk -F= '/^VERSION_CODENAME/{print$2}' /etc/os-release) main" | sudo tee /etc/apt/sources.list.d/adoptium.list
sudo apt update
sudo apt install -y temurin-21-jdk

Linux (Fedora/RHEL) — repositorio oficial de Adoptium vía dnf:

sudo tee /etc/yum.repos.d/adoptium.repo > /dev/null <<'EOF'
[Adoptium]
name=Adoptium
baseurl=https://packages.adoptium.net/artifactory/rpm/$(. /etc/os-release; echo $ID)/$releasever/$basearch
enabled=1
gpgcheck=1
gpgkey=https://packages.adoptium.net/artifactory/api/gpg/key/public
EOF
sudo dnf install -y temurin-21-jdk

Al finalizar, cierre y vuelva a abrir la terminal. Verifique la instalación:

java --version
javac --version

Las dos comprobaciones deben mostrar Java 21.

Evidencia requerida:

java --version  -> 21
javac --version -> 21

Error frecuente: si aparece una versión anterior (por ejemplo Java 17), hay otro JDK primero en el Path. En Windows: where java y where javac muestran cuál se está usando; configure JAVA_HOME con la ruta del JDK 21 y priorícelo en Path, luego abra una terminal nueva.

3.2 Instalar VS Code (editor recomendado)

Producto del paso: editor de código configurado con soporte de Java.

El curso usa VS Code como editor por defecto. No es obligatorio para la Unidad I —un editor de texto simple y la terminal alcanzan—, pero facilita el resto del curso.

Windows — PowerShell como usuario normal, con winget (viene instalado en Windows 10/11):

winget install -e --id Microsoft.VisualStudioCode

macOS (con Homebrew, ya instalado en el paso 3.1):

brew install --cask visual-studio-code

Linux (Ubuntu/Debian) — con snap (viene instalado en Ubuntu):

sudo snap install --classic code

En cualquier sistema también puede descargarse el instalador desde https://code.visualstudio.com/download.

Al finalizar, instale la extensión de Java desde la terminal:

code --install-extension vscjava.vscode-java-pack

Verifique la instalación:

code --version

3.3 Compilar y ejecutar el primer programa

Producto del paso: confirmar que el ciclo escribir → compilar → ejecutar funciona, antes de sumarle variables y tipos de datos.

Java se compila primero (javac, genera un archivo .class con bytecode) y luego se ejecuta con la máquina virtual (java). El compilar/ejecutar de este paso se hace desde la terminal (o desde la terminal integrada de VS Code, instalado en el paso anterior) — no se necesita un proyecto Maven para esto en toda la Unidad I.

Crea un archivo HolaMundo.java:

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

Error frecuente: el nombre del archivo (HolaMundo.java) debe coincidir exactamente con el nombre de la clase pública (public class HolaMundo) — si no coinciden, javac rechaza la compilación.

Compila y ejecuta:

javac HolaMundo.java
java HolaMundo

Debe imprimir Hola Mundo en la terminal. Si este paso falla, el problema está en la instalación de Java o en el nombre del archivo — más simple de diagnosticar aquí, sin variables ni tipos de datos todavía de por medio.

3.4 Leer datos por teclado con Scanner

Producto del paso: confirmar que se puede pedir un dato al usuario, convertirlo al tipo correcto y operarlo — la segunda forma de Entrada descrita en 2.2.

Para pedir datos por teclado se usa la clase Scanner de la librería estándar:

import java.util.Scanner;

public class Edades {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        System.out.print("Edad: ");
        String edadTexto = sc.nextLine();
        System.out.println("Tipo antes de convertir: String (texto), no se puede sumar directamente");

        int edad = Integer.parseInt(edadTexto);
        System.out.println("Edad el proximo anio: " + (edad + 1));

        sc.close();
    }
}

Error frecuente: intentar sumar edadTexto + 1 sin convertir — en Java esto concatena el texto "1" en vez de sumar (por ejemplo, "16" + 1 da "161", no 17). El dato ingresado por teclado siempre llega como String; hay que convertirlo con Integer.parseInt() (para int) o Double.parseDouble() (para double) antes de operarlo numéricamente.

3.5 Ejercicio 1: Ficha de postulante con variables

Producto del paso: programa Java que construye una ficha usando variables y constantes.

Problema: construir una ficha de postulante, almacenando los datos en variables y usando constantes para los datos institucionales.

Resolución guiada:

  1. Comprender: se necesita separar los datos de la salida y usar tipos de datos distintos.
  2. Entradas: datos escritos en el programa y guardados en variables: texto, entero, decimal y lógico.
  3. Procesos:
  4. declarar constantes con final y nombres en mayúsculas para datos fijos.
  5. declarar variables con nombres claros para los datos del postulante.
  6. asignar un valor a cada variable según su tipo.
  7. mostrar los valores con System.out.println().
  8. Salidas: ficha de postulante construida a partir de variables.
  9. Pruebas:
  10. caso normal: ejecuta el programa y comprueba que la ficha use los valores de las variables.
  11. caso de variación: cambia postulante, edad o promedio y vuelve a compilar/ejecutar.
  12. caso de nombres: revisa si las variables describen claramente el dato que guardan.
  13. Código:
public class FichaPostulante {
    public static void main(String[] args) {
        final String INSTITUCION = "Universidad Peruana Union";
        String carrera = "Ingenieria de Sistemas";
        String postulante = "Jarib Sullon";
        int edad = 16;
        double promedio = 18.5;
        boolean admitido = true;

        System.out.println("--- Ficha de postulante ---");
        System.out.println("Institucion: " + INSTITUCION);
        System.out.println("Carrera: " + carrera);
        System.out.println("Postulante: " + postulante);
        System.out.println("Edad: " + edad);
        System.out.println("Promedio: " + promedio);
        System.out.println("Admitido: " + admitido);
    }
}

3.6 Ejercicio 2: Ficha de producto con datos ingresados por teclado

Producto del paso: programa Java que lee datos por teclado, los convierte y calcula un resultado.

Problema: solicitar por teclado los datos de un producto y calcular el precio total. Convertir cantidad y precio al tipo adecuado.

Resolución guiada:

  1. Comprender: el usuario ingresará los datos durante la ejecución; el programa debe convertirlos y calcular un resultado.
  2. Entradas: nombre del producto, categoría, cantidad y precio unitario.
  3. Procesos:
  4. leer texto con Scanner.nextLine().
  5. convertir la cantidad con Integer.parseInt() porque es un número entero.
  6. convertir el precio con Double.parseDouble() porque puede tener decimales.
  7. calcular el precio total multiplicando cantidad por precio unitario.
  8. mostrar una ficha ordenada con los datos y el resultado.
  9. Salidas: ficha de producto con precio total calculado.
  10. Pruebas:
  11. caso normal: ingresa datos completos, una cantidad entera y un precio decimal.
  12. caso de variación: prueba con otro producto y otra cantidad.
  13. caso excepcional: si escribes texto en la cantidad, Integer.parseInt() lanza NumberFormatException y el programa termina — ese caso se usa más adelante para hablar de validación y manejo de excepciones.
  14. Código:
import java.util.Scanner;

public class FichaProducto {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        System.out.print("Nombre del producto: ");
        String nombre = sc.nextLine();
        System.out.print("Categoria: ");
        String categoria = sc.nextLine();
        System.out.print("Cantidad: ");
        int cantidad = Integer.parseInt(sc.nextLine());
        System.out.print("Precio unitario: ");
        double precio = Double.parseDouble(sc.nextLine());

        double total = cantidad * precio;

        System.out.println("--- Ficha de producto ---");
        System.out.println("Nombre: " + nombre);
        System.out.println("Categoria: " + categoria);
        System.out.println("Cantidad: " + cantidad);
        System.out.println("Precio unitario: " + precio);
        System.out.println("Total: " + total);

        sc.close();
    }
}

3.7 Ejercicio 3: Código de postulante con formato exacto

Producto del paso: programa Java que construye una salida con formato exacto, concatenando texto.

Problema: leer el nombre del postulante, el año de postulación, el semestre y el puesto de ingreso. Mostrar una ficha con esos datos y un código formado por el año, el semestre, un guion y el puesto.

Entrada:

  • Nombre del postulante como texto.
  • Año de postulación como texto numérico.
  • Semestre como texto numérico.
  • Puesto de ingreso como texto de cuatro dígitos.

Salida esperada:

POSTULANTE: Ana
ANIO: 2026
SEMESTRE: 1
PUESTO: 0415
CODIGO: 20261-0415

Resolución guiada:

  1. Comprender: el programa debe leer datos y mostrarlos con formato exacto.
  2. Entradas: postulante, anio, semestre y puesto, todos como String (no se convierten a número porque el puesto conserva ceros a la izquierda, algo que int no puede representar).
  3. Procesos:
  4. leer cada dato con Scanner.nextLine().
  5. conservar el puesto con cuatro dígitos, por ejemplo "0415".
  6. construir el código concatenando anio, semestre, "-" y puesto con el operador +.
  7. Salidas: datos del postulante y código de registro.
  8. Pruebas: usa el ejemplo y luego cambia nombre, año, semestre y puesto.
  9. Código:
import java.util.Scanner;

public class CodigoPostulante {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        System.out.print("Postulante: ");
        String postulante = sc.nextLine();
        System.out.print("Anio: ");
        String anio = sc.nextLine();
        System.out.print("Semestre: ");
        String semestre = sc.nextLine();
        System.out.print("Puesto: ");
        String puesto = sc.nextLine();

        String codigo = anio + semestre + "-" + puesto;

        System.out.println("POSTULANTE: " + postulante);
        System.out.println("ANIO: " + anio);
        System.out.println("SEMESTRE: " + semestre);
        System.out.println("PUESTO: " + puesto);
        System.out.println("CODIGO: " + codigo);

        sc.close();
    }
}

Error frecuente: convertir puesto a int para "limpiar" el dato — al hacerlo, "0415" se convierte en 415 y el código final queda mal formado (20261-415 en vez de 20261-0415). Un dato con ceros a la izquierda que nunca se opera aritméticamente debe quedarse como String.

4. Crea: actividad autónoma

Tiempo: 2h fuera del aula.

4.1 Actividad

Replicación autónoma del patrón de fichas de datos con variables, constantes y entrada por teclado en Java, aplicado a tres entidades distintas a las trabajadas en clase, documentada en evidencia individual.

Completa y evidencia estas tareas:

  1. Ficha de un versículo bíblico favorito, con variables declaradas directamente en el código: libro (String), capítulo (int), versículo (int) y texto (String).
  2. Ficha de tu mascota favorita (o una imaginaria), con datos ingresados por teclado: nombre (String), especie (String), edad (int) y peso (double).
  3. Un ejercicio nuevo con una entidad de tu elección (un dato real que te interese representar), desarrollado en dos versiones: primero como ficha simple con variables, luego con datos ingresados por teclado. Este tercer ejercicio es el producto de la sesión.

4.2 Propósito

Que cada estudiante demuestre, de forma individual y fuera del aula, que puede reproducir el patrón construido en clase sin el acompañamiento del docente.

Cada estudiante documenta, en Java, tres fichas de datos adicionales a las trabajadas en clase, eligiendo libremente la entidad del tercer ejercicio.

4.3 Indicaciones

Entrega un PDF con el siguiente nombre:

S01_FP_ApellidoNombre.pdf

Cada captura de pantalla del informe debe mostrar, sin recortar, el reloj del sistema (fecha y hora) y tu usuario o foto de perfil (Windows, VS Code o navegador) visibles en pantalla — es lo que permite verificar que la evidencia es tuya y que corresponde al momento real de tu trabajo.

4.3.1 Estructura del informe

Datos del estudiante

  • Nombre:
  • Sesión: S01 - Algoritmos y Datos
  • Link de GitHub:

Evidencia técnica

Incluye capturas o salidas con una breve explicación debajo de cada una, organizadas en los mismos 4 bloques de la rúbrica (4.6) — así queda claro qué evidencia corresponde a cada criterio evaluado:

  1. Instalación y ejecución
    • Captura de java --version y javac --version mostrando Java 21.
    • Captura de la compilación sin errores (javac) de las tres fichas.
    • Captura de la ejecución (java) de las tres fichas con datos de prueba.
  2. Tipos de datos y variables
    • Código fuente completo (.java) de las tres fichas, con variables y constantes correctamente tipadas.
  3. Entrada por teclado y conversión
    • Código y captura de ejecución de la ficha de mascota y de la segunda versión de la entidad propia, mostrando la conversión de tipos con Integer.parseInt()/Double.parseDouble().
  4. Entidad propia
    • Código y capturas de las dos versiones (variables directas y datos por teclado) de la entidad elegida en el ejercicio 3, con una breve justificación de por qué se eligió.

Error o hallazgo

Describe un error de compilación o de conversión de tipos que hayas enfrentado y cómo lo resolviste.

Reflexión técnica breve

Responde en 5 a 8 líneas:

¿Qué diferencia encontraste entre programar con tipos explícitos en Java
y lo que conoces de otros lenguajes sin tipos declarados? ¿Qué ventaja o
dificultad te generó tener que declarar el tipo de cada variable?

4.4 Criterios mínimos de aceptación

La evidencia individual se considera completa si:

  • El archivo respeta el nombre solicitado.
  • El entorno utiliza Java 21 (java --version en la evidencia).
  • Los tres programas compilan sin errores y ejecutan correctamente.
  • Las variables tienen nombres claros y el tipo correcto para el dato que guardan.
  • Las constantes usan final y mayúsculas.
  • La entidad del ejercicio 3 está bien definida y justificada por el propio estudiante.
  • Cada captura de la evidencia técnica muestra el reloj del sistema y el usuario/perfil visible, sin recortar.
  • Las fechas y horas de las capturas son coherentes con el historial de commits de su repositorio en GitHub.
  • Incluye un error o hallazgo técnico diagnosticado.
  • Incluye la reflexión técnica breve solicitada.

4.5 Preguntas de defensa

  1. ¿Qué diferencia hay entre declarar una variable y asignarle un valor?
  2. ¿Por qué un dato ingresado por Scanner siempre llega como String, aunque represente un número?
  3. ¿Qué pasa si intentas sumar dos valores String en vez de convertirlos primero?
  4. ¿Cuándo conviene usar final y cuándo una variable normal?
  5. ¿Por qué el código de postulante debe conservar el puesto como String y no como int?

4.6 Rúbrica de evaluación

Tabla 3. Rúbrica de evaluación

Criterio Peso (%) A (20 pts) B (15 pts) C (10 pts) D (5 pts) Nivel obtenido
1. Instalación y ejecución* 25 Java 21 verificado y las tres fichas compilan y ejecutan sin errores. Java 21 instalado, ejecución de las tres fichas con detalles menores. Instalación o ejecución incompleta en alguna de las tres fichas. Las fichas no compilan.
2. Tipos de datos y variables* 25 Tipos correctos en las tres fichas, nombres claros y constantes bien usadas. Tipos y nombres correctos con detalles menores. Uso parcial o inconsistente de tipos en alguna ficha. No declara tipos ni variables correctamente.
3. Entrada por teclado y conversión* 25 Scanner y conversión de tipos aplicados correctamente en los ejercicios que lo requieren (ficha de mascota y segunda versión de la entidad propia). Aplicado con detalles menores. Conversión incompleta o con errores. No usa Scanner ni convierte tipos.
4. Entidad propia* 25 Entidad clara, bien justificada, ambas versiones (variables directas y datos por teclado) completas. Entidad coherente, alguna versión incompleta. Entidad poco clara o versiones muy básicas. No presenta producto propio.

* Agregado manual.

Nota final = suma de (Peso / 100 × Puntos del nivel obtenido) = ____ / 20.

Para usar la rúbrica con IA, solicita:

Evalúa el PDF usando la rúbrica de la sesión.
Para cada criterio selecciona el nivel obtenido usando la escala A=20, B=15, C=10, D=5 puntos.
Justifica brevemente cada nivel asignado.
Verifica que cada captura muestre reloj del sistema y usuario/perfil visible, y que las fechas sean coherentes con el historial de commits de GitHub. Si falta esta evidencia o hay inconsistencias, indícalo explícitamente antes de calificar.
Calcula la nota final con la fórmula: suma de (Peso/100 × Puntos del nivel obtenido), directamente sobre 20.
Indica 2 fortalezas y 2 recomendaciones.

5. Cierre

Tiempo: 5 min.

Resumen breve: hoy se construyeron las primeras fichas de datos en Java, aplicando el modelo Entrada-Proceso-Salida con variables, constantes y tipos correctos — la base conceptual para todo el portafolio de la Unidad 1.

Dinámica participativa: en una ronda rápida, cada estudiante comparte en una frase qué entidad eligió para su ejercicio 3 (la entidad propia) y por qué.

Metacognición: cada estudiante responde en voz alta o por escrito: ¿qué parte de la sesión te costó más entender, y cómo la resolviste?

Proyección: las variables, tipos y constantes de hoy son la base directa de S2 (programación secuencial), que opera sobre estos mismos datos; en un contexto profesional real, cualquier sistema que gestione información real —personas, productos, pagos— parte de este mismo ejercicio: representar correctamente un dato antes de procesarlo.

Bibliografía

  1. Eclipse Adoptium. (2024). Temurin releases. Eclipse Foundation. https://adoptium.net/
  2. Oracle Corporation. (2024). Java SE 21 documentation. https://docs.oracle.com/en/java/javase/21/
  3. Oracle Corporation. (2024). Class Scanner (Java SE 21 & JDK 21). https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/util/Scanner.html
  4. Microsoft. (2024). Visual Studio Code documentation. https://code.visualstudio.com/docs