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¶
- Algoritmos y su estructura básica.
- Representación de algoritmos: lenguaje natural, pseudocódigo, diagrama de flujo.
- Datos, tipos de datos y variables en Java.
- 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
- ¿Qué otro dato del mundo real, además de un postulante o un producto, podrías representar con variables?
- ¿Por qué un programa necesita distinguir entre texto, número entero y número decimal?
Comprensión de tipos de datos
- ¿Qué diferencia hay entre escribir un valor directo en el código y pedirlo por teclado?
- ¿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:
- Leer dos números.
- Sumar los números.
- 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¶
- Comprender el problema: ¿qué se pide?
- Identificar entradas: ¿qué datos necesito?
- Diseñar el proceso: ¿qué operaciones o decisiones realizaré?
- Definir salidas: ¿qué debe mostrar el programa?
- Diseñar pruebas: ¿con qué casos comprobaré que funciona?
- 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:
- Comprender: se necesita separar los datos de la salida y usar tipos de datos distintos.
- Entradas: datos escritos en el programa y guardados en variables: texto, entero, decimal y lógico.
- Procesos:
- declarar constantes con
finaly nombres en mayúsculas para datos fijos. - declarar variables con nombres claros para los datos del postulante.
- asignar un valor a cada variable según su tipo.
- mostrar los valores con
System.out.println(). - Salidas: ficha de postulante construida a partir de variables.
- Pruebas:
- caso normal: ejecuta el programa y comprueba que la ficha use los valores de las variables.
- caso de variación: cambia
postulante,edadopromedioy vuelve a compilar/ejecutar. - caso de nombres: revisa si las variables describen claramente el dato que guardan.
- 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:
- Comprender: el usuario ingresará los datos durante la ejecución; el programa debe convertirlos y calcular un resultado.
- Entradas: nombre del producto, categoría, cantidad y precio unitario.
- Procesos:
- leer texto con
Scanner.nextLine(). - convertir la cantidad con
Integer.parseInt()porque es un número entero. - convertir el precio con
Double.parseDouble()porque puede tener decimales. - calcular el precio total multiplicando cantidad por precio unitario.
- mostrar una ficha ordenada con los datos y el resultado.
- Salidas: ficha de producto con precio total calculado.
- Pruebas:
- caso normal: ingresa datos completos, una cantidad entera y un precio decimal.
- caso de variación: prueba con otro producto y otra cantidad.
- caso excepcional: si escribes texto en la cantidad,
Integer.parseInt()lanzaNumberFormatExceptiony el programa termina — ese caso se usa más adelante para hablar de validación y manejo de excepciones. - 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:
- Comprender: el programa debe leer datos y mostrarlos con formato exacto.
- Entradas:
postulante,anio,semestreypuesto, todos comoString(no se convierten a número porque el puesto conserva ceros a la izquierda, algo queintno puede representar). - Procesos:
- leer cada dato con
Scanner.nextLine(). - conservar el puesto con cuatro dígitos, por ejemplo
"0415". - construir el código concatenando
anio,semestre,"-"ypuestocon el operador+. - Salidas: datos del postulante y código de registro.
- Pruebas: usa el ejemplo y luego cambia nombre, año, semestre y puesto.
- 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:
- 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). - Ficha de tu mascota favorita (o una imaginaria), con datos ingresados por teclado: nombre (
String), especie (String), edad (int) y peso (double). - 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:
- Instalación y ejecución
- Captura de
java --versionyjavac --versionmostrando 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.
- Captura de
- Tipos de datos y variables
- Código fuente completo (
.java) de las tres fichas, con variables y constantes correctamente tipadas.
- Código fuente completo (
- 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().
- 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
- 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 --versionen 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
finaly 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¶
- ¿Qué diferencia hay entre declarar una variable y asignarle un valor?
- ¿Por qué un dato ingresado por
Scannersiempre llega comoString, aunque represente un número? - ¿Qué pasa si intentas sumar dos valores
Stringen vez de convertirlos primero? - ¿Cuándo conviene usar
finaly cuándo una variable normal? - ¿Por qué el código de postulante debe conservar el puesto como
Stringy no comoint?
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¶
- Eclipse Adoptium. (2024). Temurin releases. Eclipse Foundation. https://adoptium.net/
- Oracle Corporation. (2024). Java SE 21 documentation. https://docs.oracle.com/en/java/javase/21/
- 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
- Microsoft. (2024). Visual Studio Code documentation. https://code.visualstudio.com/docs