S2 - Programación Secuencial¶
1. Introducción¶
Tiempo: 1h 30min (40 min de contexto y propósito + 50 min de revisión del trabajo autónomo de S1).
1.1 Presentación de la sesión¶
Un dato aislado no resuelve nada por sí solo — hace falta combinarlo con otros mediante operadores para obtener un resultado: un promedio, un total, una condición que se cumple o no. Esta sesión trabaja operadores de asignación, aritméticos, relacionales y lógicos, y los combina en expresiones dentro de un algoritmo todavía puramente secuencial, sin decisiones ni repeticiones.
Los 50 min adicionales de esta sección se usan para revisar el trabajo autónomo de S1: las tres fichas entregadas (versículo, mascota, entidad propia) y las dificultades encontradas al leer datos por teclado y convertir tipos.
1.2 Índice¶
- Operadores de asignación y aritméticos.
- Operadores relacionales y lógicos.
- Expresiones, precedencia y conversión de tipos.
- Algoritmos secuenciales: entrada, proceso y salida con cálculos.
1.3 Propósito de aprendizaje¶
Al concluir la clase, estarás en condiciones de:
- Construir programas secuenciales en Java 21 que usen operadores de asignación, aritméticos, relacionales y lógicos para calcular y evaluar resultados a partir de datos ingresados por teclado.
1.4 Producto de sesión¶
Programa Java ejecutable que lee datos por teclado, calcula un resultado mediante operadores y expresiones, y evalúa condiciones lógicas sin usar estructuras condicionales.
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 | Repasar el proyecto de S1 (variables, tipos, Scanner) y traer evidencia de que compila y ejecuta. Trabajo individual, antes de clase. |
Proyecto de S1. |
| Clase presencial | Explicación guiada de operadores, expresiones, precedencia y conversión de tipos, 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: calcular antes de decidir¶
Toda transacción de negocio necesita cálculos antes de poder mostrar un resultado: un promedio, un subtotal con impuestos, un vuelto, una condición de habilitación. Hoy construimos programas que leen datos, los combinan con operadores y expresiones, y muestran un resultado calculado, todavía sin usar decisiones (if) ni repeticiones.
Preguntas de análisis
Activación de conocimientos previos
- ¿Qué cálculo de tu vida diaria podrías representar con una sola expresión aritmética?
Comprensión de operadores
- ¿Qué diferencia hay entre
5 / 2y5.0 / 2en Java? - ¿Por qué el resultado de una comparación (
promedio >= 11) es un dato de tipoboolean? - ¿Cómo combinarías dos condiciones (por ejemplo, edad mínima y promedio mínimo) sin usar
if?
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: cálculos con operadores y expresiones sobre los datos representados en S1.
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 S2 today;
2. Explica¶
Tiempo: 50 min.
2.1 Operadores de asignación¶
El operador principal es =, que guarda un valor o el resultado de una expresión en una variable.
double subtotal = precio * cantidad;
También existen operadores de asignación abreviada:
+=suma y asigna.-=resta y asigna.*=multiplica y asigna./=divide y asigna.
int total = 5;
total += 15;
2.2 Operadores aritméticos¶
Tabla 2. Operadores aritméticos en Java
| Operador | Significado | Ejemplo |
|---|---|---|
+ |
Suma | precio + igv |
- |
Resta | total - descuento |
* |
Multiplicación | precio * cantidad |
/ |
División | total / cantidad |
% |
Residuo (módulo) | entradas % estudiantes |
Java no tiene un operador de división entera (// de otros lenguajes) ni de potencia (**). En su lugar:
- La división entre dos
inttrunca automáticamente el resultado a entero:25 / 6da4(equivalente a//). Si al menos uno de los operandos esdouble, la división es decimal:25.0 / 6da4.166.... - La potencia se calcula con
Math.pow(base, exponente), que siempre devuelvedouble:Math.pow(a, 2)para elevar al cuadrado. - La raíz cuadrada se calcula con
Math.sqrt(a), y la raíz cúbica conMath.cbrt(a).
Error frecuente: dividir dos int esperando un resultado decimal — 7 / 2 da 3, no 3.5. Para obtener el decimal, al menos un operando debe ser double (por ejemplo, 7.0 / 2 o convirtiendo uno de los dos con (double)).
2.3 Operadores relacionales¶
Permiten comparar dos valores. El resultado de una comparación es un dato de tipo boolean: true o false.
Tabla 3. Operadores relacionales
| Operador | Significado |
|---|---|
== |
Igual que |
!= |
Diferente de |
> |
Mayor que |
< |
Menor que |
>= |
Mayor o igual que |
<= |
Menor o igual que |
boolean aprueba = promedio >= 11;
Error frecuente: comparar String con == (por ejemplo, respuesta == "si") — en Java, == compara referencias de objetos, no el contenido del texto; para comparar el contenido de dos String se usa .equals().
2.4 Operadores lógicos¶
Permiten combinar expresiones lógicas.
Tabla 4. Operadores lógicos
| Operador | Significado |
|---|---|
&& |
Y lógico: se cumple si ambas expresiones son verdaderas. |
\|\| |
O lógico: se cumple si al menos una expresión es verdadera. |
! |
Negación: invierte el valor lógico. |
boolean apto = edad >= 16 && promedio >= 14;
2.5 Expresiones, precedencia y conversión de tipos¶
Una expresión combina valores, variables y operadores para obtener un nuevo resultado.
double promedio = (nota1 + nota2 + nota3) / 3; // expresión aritmética
boolean aprueba = promedio >= 11; // expresión relacional
boolean apto = edad >= 16 && promedio >= 14; // expresión lógica
Los paréntesis aclaran el orden de evaluación y evitan ambigüedad:
boolean cumple = (promedio >= 11) && (asistencia >= 70);
Los datos ingresados por Scanner siempre llegan como String (ver S1, sección 3.4); antes de usarlos en una expresión aritmética o relacional deben convertirse con Integer.parseInt() o Double.parseDouble().
2.6 Algoritmos secuenciales¶
Un algoritmo secuencial ejecuta instrucciones una después de otra, sin decisiones ni repeticiones.
Figura 2. Estructura de un algoritmo secuencial con cálculos
flowchart TD
inicio([Inicio]) --> entrada[/Leer datos/]
entrada --> proceso[Realizar cálculos y expresiones]
proceso --> salida[/Mostrar resultados/]
salida --> fin([Fin])
En esta sesión los problemas se resuelven leyendo datos por teclado, calculando resultados con operadores y expresiones, y mostrando una salida ordenada — el mismo modelo Entrada-Proceso-Salida de S1, ahora con cálculos.
2.7 Metodología para resolver problemas¶
- Comprender el problema: ¿qué se pide?
- Identificar entradas: ¿qué datos necesito?
- Diseñar el proceso: ¿qué operadores y expresiones aplicaré, y en qué orden?
- 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 programas secuenciales que combinan operadores y expresiones para calcular resultados.
Propósito de la actividad: aplicar operadores de asignación, aritméticos, relacionales y lógicos en expresiones compuestas, verificando la compilación y ejecución de cada ejercicio antes de continuar al siguiente.
Orientaciones metodológicas: en el laboratorio, el docente desarrolla el mini laboratorio de operadores y los tres ejercicios guiados paso a paso frente a la clase; los estudiantes replican cada paso en su propio equipo, verificando la compilación y ejecución antes de avanzar al siguiente.
Actividades para realizar:
- 3.1 Mini laboratorio: operadores aritméticos, relacionales y lógicos.
- 3.2 Ejercicio 1: promedio de notas.
- 3.3 Ejercicio 2: boleta de venta con IGV.
- 3.4 Ejercicio 3: habilitación académica sin condicionales.
3.1 Mini laboratorio: operadores aritméticos, relacionales y lógicos¶
Producto del paso: evidencia de que cada operador produce el resultado esperado, antes de resolver un problema completo.
public class MiniLaboratorio {
public static void main(String[] args) {
int a = 12;
int b = 5;
System.out.println("Suma: " + (a + b));
System.out.println("Resta: " + (a - b));
System.out.println("Multiplicacion: " + (a * b));
System.out.println("Division decimal: " + (a / (double) b));
System.out.println("Division entera: " + (a / b));
System.out.println("Residuo: " + (a % b));
System.out.println("Potencia: " + Math.pow(a, 2));
System.out.println("Raiz cuadrada: " + Math.sqrt(a));
int edad = 17;
double promedio = 15.5;
int asistencia = 82;
boolean cumpleEdad = edad >= 16;
boolean cumplePromedio = promedio >= 14;
boolean cumpleAsistencia = asistencia >= 80;
boolean apto = cumpleEdad && cumplePromedio && cumpleAsistencia;
System.out.println("Cumple edad: " + cumpleEdad);
System.out.println("Cumple promedio: " + cumplePromedio);
System.out.println("Cumple asistencia: " + cumpleAsistencia);
System.out.println("Apto: " + apto);
}
}
Nota: Java imprime los valores boolean en minúscula (true/false), sin importar cómo se escriban las palabras clave en el código.
3.2 Ejercicio 1: Promedio de notas¶
Producto del paso: programa Java que lee tres notas, calcula el promedio y lo muestra con dos decimales.
Problema: construir un programa que lea tres notas, calcule el promedio y lo muestre con dos decimales.
Resolución guiada:
- Comprender: se necesita obtener un solo promedio a partir de tres notas.
- Entradas:
nota1,nota2ynota3, como números decimales. - Procesos:
- leer las tres notas con
Scannery convertirlas conDouble.parseDouble(). - sumar las tres notas y dividir entre
3. - redondear el resultado a dos decimales al mostrarlo, con
Math.round(promedio * 100) / 100.0. - Salidas: promedio final.
- Pruebas: usa notas como
14,16y13para verificar el cálculo. - Código:
import java.util.Scanner;
public class PromedioNotas {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.print("Nota 1: ");
double nota1 = Double.parseDouble(sc.nextLine());
System.out.print("Nota 2: ");
double nota2 = Double.parseDouble(sc.nextLine());
System.out.print("Nota 3: ");
double nota3 = Double.parseDouble(sc.nextLine());
double promedio = (nota1 + nota2 + nota3) / 3;
double promedioRedondeado = Math.round(promedio * 100) / 100.0;
System.out.println("Promedio: " + promedioRedondeado);
}
}
3.3 Ejercicio 2: Boleta de venta con IGV¶
Producto del paso: programa Java que calcula el subtotal, el IGV y el total a pagar de una compra.
Problema: leer el precio unitario y la cantidad comprada. Calcular el subtotal, el IGV (18% del subtotal) y el total a pagar.
Resolución guiada:
- Comprender: una boleta requiere calcular importes en orden, uno a partir del anterior.
- Entradas:
precioUnitariocomodoubleycantidadcomoint. - Procesos:
- calcular el subtotal multiplicando precio por cantidad.
- calcular el IGV como el 18% del subtotal (
subtotal * 0.18). - calcular el total sumando subtotal e IGV.
- Salidas: subtotal, IGV y total.
- Pruebas: usa
precio = 25.50ycantidad = 3. - Código:
import java.util.Scanner;
public class BoletaVenta {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.print("Precio unitario: ");
double precioUnitario = Double.parseDouble(sc.nextLine());
System.out.print("Cantidad: ");
int cantidad = Integer.parseInt(sc.nextLine());
double subtotal = precioUnitario * cantidad;
double igv = subtotal * 0.18;
double total = subtotal + igv;
System.out.println("Subtotal: " + subtotal);
System.out.println("IGV: " + igv);
System.out.println("Total: " + total);
}
}
Error frecuente: calcular el IGV o el total antes de tener el subtotal completo — cada cálculo de esta boleta depende del resultado del paso anterior; invertir el orden produce un total incorrecto.
3.4 Ejercicio 3: Habilitación académica sin condicionales¶
Producto del paso: programa Java que evalúa si un estudiante queda habilitado, usando solo expresiones relacionales y lógicas, sin if.
Problema: leer el nombre de un estudiante, tres notas, la cantidad de clases asistidas y el total de clases. Calcular el promedio, el porcentaje de asistencia y verificar si el estudiante queda habilitado.
Reglas:
- Cumple nota si su promedio es mayor o igual que
11. - Cumple asistencia si su porcentaje de asistencia es mayor o igual que
70. - Está habilitado si cumple ambas condiciones.
Salida esperada:
ESTUDIANTE: Ana
PROMEDIO: 13.67
ASISTENCIA: 80.0
CUMPLE_NOTA: true
CUMPLE_ASISTENCIA: true
HABILITADO: true
Resolución guiada:
- Comprender: no se debe usar
if; solo se evalúan expresiones aritméticas, relacionales y lógicas. - Entradas:
estudiante(String),nota1,nota2,nota3(double),asistidasytotalClases(int). - Procesos:
- calcular el promedio de las tres notas.
- calcular el porcentaje de asistencia:
asistidas * 100.0 / totalClases. - comparar promedio y asistencia con los mínimos requeridos (
boolean). - combinar ambas condiciones con
&&. - Salidas: nombre, promedio, asistencia y los tres resultados lógicos, con las etiquetas exactas del formato pedido.
- Pruebas: usa un caso donde todo se cumpla y otro donde falle un requisito (por ejemplo, asistencia menor a 70).
- Código:
import java.util.Scanner;
public class HabilitacionAcademica {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.print("Estudiante: ");
String estudiante = sc.nextLine();
System.out.print("Nota 1: ");
double nota1 = Double.parseDouble(sc.nextLine());
System.out.print("Nota 2: ");
double nota2 = Double.parseDouble(sc.nextLine());
System.out.print("Nota 3: ");
double nota3 = Double.parseDouble(sc.nextLine());
System.out.print("Clases asistidas: ");
int asistidas = Integer.parseInt(sc.nextLine());
System.out.print("Total de clases: ");
int totalClases = Integer.parseInt(sc.nextLine());
double promedio = (nota1 + nota2 + nota3) / 3;
double asistencia = asistidas * 100.0 / totalClases;
boolean cumpleNota = promedio >= 11;
boolean cumpleAsistencia = asistencia >= 70;
boolean habilitado = cumpleNota && cumpleAsistencia;
System.out.println("ESTUDIANTE: " + estudiante);
System.out.println("PROMEDIO: " + promedio);
System.out.println("ASISTENCIA: " + asistencia);
System.out.println("CUMPLE_NOTA: " + cumpleNota);
System.out.println("CUMPLE_ASISTENCIA: " + cumpleAsistencia);
System.out.println("HABILITADO: " + habilitado);
}
}
Error frecuente: calcular asistidas / totalClases sin forzar la división decimal — al ser ambos int, el resultado trunca a 0 cuando asistidas < totalClases. Se corrige multiplicando por 100.0 (double) antes de dividir, como en el código anterior.
4. Crea: actividad autónoma¶
Tiempo: 2h fuera del aula.
4.1 Actividad¶
Replicación autónoma de programas secuenciales con operadores, expresiones y conversión de tipos en Java, aplicados a problemas distintos a los trabajados en clase, documentada en evidencia individual.
Completa y evidencia estas tareas:
- Programa que calcule el sueldo de un trabajador a partir de horas trabajadas, pago por hora y bonificación porcentual.
- Programa que calcule el vuelto que debe recibir un cliente después de una compra, y una expresión lógica que indique si el pago realizado cubre el total.
- Un ejercicio nuevo, elegido entre: conversión de minutos a horas y minutos (con
/y%enteros); área de un triángulo y de un círculo usando una constantePI; boleta con descuento y una expresión lógica que indique si el descuento fue aplicado; o verificador de requisitos (edad mínima, promedio mínimo y asistencia mínima) sin usarif. 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 de programación secuencial construido en clase sin el acompañamiento del docente.
Cada estudiante documenta, en Java, tres programas secuenciales adicionales a los trabajados en clase, eligiendo libremente la entidad del tercer ejercicio.
4.3 Indicaciones¶
Entrega un PDF con el siguiente nombre:
S02_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: S02 - Programación Secuencial
- 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:
- Operadores aritméticos y de asignación
- Código y salida del mini laboratorio (3.1) y de la boleta de venta (3.3).
- Operadores relacionales y lógicos
- Código y salida del ejercicio de habilitación académica (3.4).
- Expresiones y conversión de tipos
- Código y salida del ejercicio de promedio (3.2), mostrando la conversión con
Double.parseDouble().
- Código y salida del ejercicio de promedio (3.2), mostrando la conversión con
- Entidad propia
- Código y capturas de los tres programas de la actividad autónoma (4.1), incluido el ejercicio 3 elegido libremente.
Error o hallazgo
Describe un error de cálculo, de división entera 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:
¿Por qué en Java conviene revisar si una división es entre dos "int" antes
de confiar en su resultado? ¿Qué error te habría generado no revisarlo?
Anexo: Feedback de la sesión
Pega esta página como la última hoja del PDF, con tus respuestas.
- ¿Cuál es el aprendizaje más importante que te llevas de la clase de hoy?
- ¿Qué punto de la clase te resultó más confuso o te dejó con dudas?
- ¿Tienes alguna pregunta que te gustaría que sea respondida la siguiente clase?
- Sobre tu nivel de comprensión de la clase de hoy, marca una opción:
- ¡Entendido! - Lo domino y podría explicarlo.
- Más o menos. - Entendí la idea general, pero tengo dudas.
- Necesito ayuda. - Me siento perdido/a con este tema.
- ¿Cómo puedo ayudarte a comprender mejor el tema?
- Pensando en tu participación y esfuerzo en la clase de hoy, ¿cómo te autoevaluarías? Marca una opción:
- Muy Comprometido/a: Me esforcé al máximo.
- Comprometido/a: Sé que podría haberme esforzado un poco más.
- Poco Comprometido/a: Hoy no di mi mejor esfuerzo.
- Mi satisfacción con la clase fue... (califica del 1 al 10, donde 1 es insatisfecho y 10 es muy satisfecho).
4.4 Criterios mínimos de aceptación¶
La evidencia individual se considera completa si:
- El archivo respeta el nombre solicitado.
- Los tres programas compilan sin errores y ejecutan correctamente.
- Se usan operadores de asignación y aritméticos correctamente.
- Al menos un programa usa operadores relacionales y lógicos.
- Las divisiones entre
intque deben ser decimales están forzadas correctamente condouble. - El ejercicio 3 está bien definido y justificado 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
7 / 2y7.0 / 2en Java? - ¿Qué tipo de dato produce siempre una expresión relacional?
- ¿Cuál es la diferencia entre
&&y||? - ¿Por qué el ejercicio de habilitación académica no usa
if? - ¿Qué operador usarías para calcular cuántas entradas sobran al repartirlas entre varios estudiantes?
4.6 Rúbrica de evaluación¶
Tabla 5. Rúbrica de evaluación
| Criterio | Peso (%) | A (20 pts) | B (15 pts) | C (10 pts) | D (5 pts) | Nivel obtenido |
|---|---|---|---|---|---|---|
| 1. Operadores aritméticos y de asignación* | 25 | Cálculos correctos en todos los ejercicios, sin errores de división entera. | Cálculos correctos con detalles menores. | Cálculos parciales o con errores de tipo. | No aplica operadores aritméticos correctamente. | |
| 2. Operadores relacionales y lógicos* | 25 | Expresiones relacionales y lógicas correctas y bien combinadas. | Expresiones correctas con detalles menores. | Uso parcial o confuso. | No usa operadores relacionales ni lógicos. | |
| 3. Expresiones y conversión de tipos* | 25 | Expresiones compuestas claras; conversiones de tipo correctas en todos los casos. | Expresiones y conversiones correctas con detalles menores. | Conversión incompleta o con errores. | No convierte tipos correctamente. | |
| 4. Entidad propia* | 25 | Ejercicio 3 claro, bien justificado y completo, con los otros dos programas correctos. | Ejercicio 3 coherente, con detalles menores. | Ejercicio 3 poco claro o incompleto. | 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 los datos representados en S1 se combinaron mediante operadores y expresiones para calcular resultados — sumas, promedios, comparaciones y condiciones lógicas — todavía sin decisiones ni repeticiones.
Dinámica participativa: en una ronda rápida, cada estudiante comparte en una frase qué ejercicio eligió para el 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 expresiones y operadores de hoy son la base directa de S3 (programación condicional), que usa exactamente estos mismos operadores relacionales y lógicos dentro de un if; en un contexto profesional, cualquier cálculo de negocio (un descuento, un impuesto, una validación) se construye con este mismo patrón de operadores y expresiones antes de decidir qué hacer con el resultado.
Bibliografía¶
- Oracle Corporation. (2024). Java SE 21 documentation. https://docs.oracle.com/en/java/javase/21/
- Oracle Corporation. (2024). Class Math (Java SE 21 & JDK 21). https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/lang/Math.html