1

INSTITUTO TECNOLÓGICO SUPERIOR DE COATZACOALCOS

INGENIERÍA EN SISTEMAS COMPUTACIONALES

TOPICOS AVANZADOS DE PROGRAMACION

E24J24-SCD1027

Unidad 2: Componentes y librerías

PROYECTO INTEGRADOR 2

DOCENTE: Ing. Nelly Janeth Velasco Escobedo

NOMBRES:
Gonzalez Benitez G.
Hernandez Collado Dibanhi Michelle
Hernandez Palafox Genesis Isabel
Vargas Gutierrez Maria Yeleni
 2

Tabla de contenido
Introducción: ..................................................................................................................................... 3
Planteamiento del proyecto: ............................................................................................................. 4
Solución: ............................................................................................................................................. 4
Elaboración del programa: .............................................................................................................. 5
Clase principal ................................................................................................................................. 5
Servicio del IMC ............................................................................................................................. 9
Consumo de Agua ......................................................................................................................... 11
Servicio de ingesta calórica ........................................................................................................... 12
Código completo en texto: .............................................................................................................. 14
Código completo en Imagen: .......................................................................................................... 21
Resultados: ....................................................................................................................................... 26
Conclusión: ...................................................................................................................................... 28
 3

Introducción:
Para iniciar, los componentes son unidades de código reutilizables que encapsulan una
funcionalidad específica dentro de una aplicación. Permiten dividir aplicaciones complejas
en partes más manejables, facilitando la mantenibilidad y la escalabilidad del código.En
Java, los componentes son partes modulares y reutilizables de una aplicación que
encapsulan una funcionalidad específica. Estos pueden incluir clases, interfaces, y paquetes
que se pueden combinar para construir aplicaciones más complejas. Mientras que las
librerías son colecciones de código preescrito que proporcionan soluciones para tareas
comunes, evitando la necesidad de escribir código desde cero. Incluyen desde funciones
matemáticas hasta herramientas para la manipulación de datos. Las librerías en Java son
colecciones de clases y métodos preescritos que los desarrolladores pueden usar para
realizar tareas comunes, evitando así la necesidad de escribir código desde cero.
Ejemplo:

• Java Standard Library: Incluye paquetes como java.util para estructuras de datos,
java.io para entrada/salida, y java.net para redes.
Una de sus ventajas principales es que permiten ahorrar tiempo, aprovechar soluciones
optimizadas y probadas, y centrarse en la lógica específica de la aplicación.
En resumen, en el desarrollo avanzado en Java, el uso efectivo de componentes y librerías
es fundamental para crear aplicaciones eficientes y mantenibles, permitiendo a los
desarrolladores abordar problemas complejos de manera más estructurada y eficiente.
 4

Planteamiento del proyecto:

Realizar una aplicación con GUI que implemente una librería para el caso propuesto.
La aplicación debe estar compuesta de por lo menos 3 librerías distintas y una clase
principal para hacer uso de las librerías. Cada librería debe contener por lo menos 4
métodos distintos aparte del constructor.

Solución:
Realizar un programa tomando en cuenta el ámbito de salud para el beneficio de todas las personas
en donde se les mostrara por medio de un menú, su índice de masa corporal, así como también
consejos para su consumo de agua e ingesta de calorías.
 5

Elaboración del programa:

Clase principal
1. Como primer paso, iniciaremos con lo básico que será importa las clases necesarias para
crear la GUI (JFrame, JButton, JLabel, etc.) y manejar eventos (ActionEvent,
ActionListener). También importa las librerías que ocuparemos y será lo principal del
proyecto ServicioDeIMC, ConsumoDeAgua y ServicioIngestaCalorica.

2. La clase principal es la siguiente:

Se debe tener en cuenta que que esta clase es un marco de ventana GUI.

3. Después tenemos la Interfaz ActionListener: ProPri implementa ActionListener,

permitiendo que la clase responda a eventos de acción, como clics de botones.
• Botones:
calcularIMCButton: Botón para calcular el Índice de Masa Corporal (IMC).
calcularAguaButton: Botón para calcular el consumo de agua diario.
registrarIngestaButton: Botón para registrar la ingesta calórica diaria.
salirButton: Botón para cerrar la aplicación.
• Etiqueta: opcionesLabel para mostrar el texto "Estas son las distintas opciones:".
• Servicios:
servicioIMC: Instancia de ServicioDeIMC para realizar cálculos relacionados con el IMC.
servicioConsumoAgua: Instancia de ConsumoDeAgua para cálculos relacionados con el
consumo de agua.
servicioIngestaCalorica: Instancia de ServicioIngestaCalorica para cálculos relacionados
con la ingesta calórica.
 6

4. Para seguir, iniciaremos con los constructores en donde la creación de instancias inicia en
“ServicioDeIMC”, “ConsumoDeAgua” y “ServicioIngestaCalorica”.

5. Para la configuración de las ventanas estaremos ocupando las líneas de código que
estuvimos viendo en clases y son las siguientes:
• setTitle("Programa Principal"): Establece el título de la ventana.
• setSize(300, 250): Define el tamaño de la ventana.
• setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE): Configura la operación de
cierre para salir del programa.
• setLocationRelativeTo(null): Centra la ventana en la pantalla.

6. Para la configuración del panel seguimos los pasos que se muestran a continuación:
• Crear un JPanel y establece su diseño a null para posicionar los componentes de
forma absoluta.
• Añadir la etiqueta opcionesLabel y establece su posición y tamaño.
• Añadir y configura cada botón, asignando posiciones y añadiendo ActionListener
para manejar eventos de clic.
• Añadir el Panel a la Ventana: Añade el panel a la ventana y hace visible la ventana.
 7

7. Ahora para los métodos, iniciamos con Método actionPerformed, en donde:

• Para identificar el Botón Presionado: Usa e.getSource() para determinar qué botón
fue presionado.
Después para la invocación del Método Correspondiente:
• calcularIMC(): Método para calcular el IMC.
• calcularConsumoAgua(): Método para calcular el consumo de agua.
• registrarIngestaCalorica(): Método para registrar la ingesta calórica.
• System.exit(0): Sale del programa cuando se presiona el botón "Salir".

8. El siguiente método que se creo fue calcularIMC, en donde se solicita los datos
correspondientes, Usa servicioIMC.calcularIMC(peso, altura) para calcular el IMC, Usa
servicioIMC.clasificarIMC(imc), servicioIMC.obtenerRecomendacion(imc) y
servicioIMC.evaluarRiesgoSalud(imc) para obtener la clasificación, recomendación y
riesgo de salud basados en el IMC y por último Construye un mensaje con los resultados y
lo muestra en un cuadro de diálogo.
 8

9. El siguiente método es calcularConsumoAgua, en este método, se solicitan los datos

Como el peso, nivel de actividad, temperatura ambiente y número de tomas de agua mediante
cuadros de diálogo.
• Utiliza métodos de servicioConsumoAgua para calcular el consumo diario de agua,
ajustarlo por temperatura, dividirlo por el número de tomas y obtener
recomendaciones sobre hidratación.
• Crea un mensaje con los resultados obtenidos, incluyendo el consumo
recomendado de agua, el número de tomas recomendadas y la cantidad de agua por
toma.
• Muestra el mensaje en un cuadro de diálogo.

10. El tercer método es registrarIngestaCalorica, en este método, de igual manera solicita los
datos al usuario como lo son la cantidad de alimentos consumidos y las calorías de cada
 9

alimento.
• Utiliza el método calcularCaloriasTotales de servicioIngestaCalorica para calcular
el total de calorías consumidas.
• Utiliza los datos de usuario para estimar las calorías recomendadas mediante el
método estimarCaloriasRecomendadas.
• Calcula el porcentaje de la ingesta calórica recomendada consumida con
calcularPorcentajeIngestaRecomendada.
• Utiliza obtenerRecomendacionIngestaCalorica para obtener una recomendación
basada en el porcentaje de ingesta.
• Por último, muestra un mensaje con las calorías recomendadas, el porcentaje de
ingesta y la recomendación en un cuadro de diálogo.

11. Para finalizar esta parte, se crea una instancia de ProPri, iniciando así la aplicación.

Servicio del IMC

1. El primer paso de esta parte es crear el constructor, el cual es por defecto que no realiza
ninguna operación especial al ser invocado

2. Después, el método siguiente calcula el Índice de Masa Corporal (IMC) utilizando la

fórmula estándar: IMC=pesoaltura2IMC=altura2peso. Toma dos parámetros: peso (en
kilogramos) y altura (en metros), y devuelve el IMC calculado como un valor de punto
flotante.

3. El siguiente es el método que clasifica el IMC en diferentes categorías según los rangos
establecidos por la Organización Mundial de la Salud (OMS). Toma el IMC como
parámetro y devuelve una cadena que representa la clasificación del IMC, que puede ser
"Bajo peso", "Normal", "Sobrepeso" o "Obesidad".
 10

4. Para casi terminar, el método de “obtenerRecomendacion” proporciona recomendaciones

de salud basadas en el IMC calculado. Toma el IMC como parámetro y devuelve una
cadena que contiene una recomendación correspondiente al IMC, como consejos sobre
ganar peso, mantener el peso actual o perder peso de manera saludable.

5. Para finalizar la primer librería, esta el método “evaluarRiesgoSalud”, en donde evalúa el

riesgo para la salud asociado con diferentes rangos de IMC. Toma el IMC como parámetro
y devuelve una cadena que describe el riesgo para la salud asociado con el IMC calculado,
como el riesgo de desnutrición, el riesgo bajo de problemas de salud relacionados con el
peso, el aumento del riesgo de enfermedades cardiovasculares o el alto riesgo de problemas
de salud graves como la diabetes tipo 2 y las enfermedades del corazón.
 11

Consumo de Agua
1. De igual manera que el anterior, iniciaremos con el constructor por defecto, es decir el que
no realiza ninguna operación especial al ser invocado.

2. Después iniciamos con el primer método que se llama “Método calcularConsumoAgua”,

este método calcula el consumo diario de agua basado en el peso y el nivel de actividad.
Multiplica el peso por un factor (0.035) para obtener una cantidad base de agua y luego
ajusta esta cantidad según el nivel de actividad. Devuelve el consumo diario de agua en
litros.

3. El método siguiente es: Método “ajustarConsumoPorTemperatura”, este se encarga de

ajustar el consumo de agua según la temperatura ambiente. Si la temperatura es mayor a 30
grados Celsius, aumenta el consumo en un 20%. Si la temperatura es menor a 10 grados
Celsius, reduce el consumo en un 20%. En otros casos, devuelve el consumo base sin
ajustes.

4. El método de Método “dividirConsumoDiario”, divide el consumo diario de agua en varias

tomas iguales. Calcula la cantidad de agua por toma dividiendo el consumo total entre el
número de tomas. Luego, llena un arreglo con estas cantidades y lo devuelve.
 12

5. Por ultimo, el método de “obtenerRecomendacionHidratacion”, proporciona

recomendaciones de hidratación según el nivel de actividad. Devuelve un mensaje
específico según el nivel de actividad dado, como recordatorios para hidratarse
regularmente o mantener una botella de agua cerca.

Estos son los pasos para entender la clase ConsumoDeAgua y sus funciones. Cada método
cumple un propósito específico en el contexto de la gestión del consumo de agua y la
hidratación adecuada.

Servicio de ingesta calórica

1. Iniciamos con el primer constructor que se utilizaron en las librerías anteriores, el cual es
por defecto

2. El primer método es, “Método calcularCaloriasTotales”, el cual calcula el total de calorías

consumidas a partir de una lista de calorías por alimento. Itera sobre la lista de calorías
consumidas y suma cada valor para obtener el total de calorías.

3. El método de “Método estimarCaloriasRecomendadas”, este método estima las calorías

diarias recomendadas basadas en la tasa metabólica basal (TMB) y el nivel de actividad del
 13

individuo. Calcula la TMB según la fórmula correspondiente al sexo del individuo y luego
ajusta este valor según el nivel de actividad.

4. El método de Método “calcularPorcentajeIngestaRecomendada” es de cierta manera

sencillo, realiza o mas bien calcula el porcentaje de ingesta calórica recomendada
consumida. Divide el total de calorías consumidas entre las calorías diarias recomendadas y
multiplica por 100 para obtener el porcentaje.

5. Por ultimo, el método de Método” obtenerRecomendacionIngestaCalorica”, proporciona

recomendaciones basadas en el porcentaje de ingesta calórica recomendada consumida. Si
el porcentaje es menor a 100, recomienda consumir más alimentos ricos en nutrientes. Si es
mayor a 100, sugiere considerar hacer ajustes en la dieta. Si es exactamente 100, indica que
la ingesta calórica está en un nivel saludable.

Cada método cumple una función específica relacionada con la gestión de la ingesta
calórica y proporciona herramientas útiles para la evaluación y recomendación nutricional.
 14

Código completo en texto:

Clase principal
import javax.swing.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;
import java.util.List;
import serviciodeimc.ServicioDeIMC;
import consumodeagua.ConsumoDeAgua;
import servicioingestacalorica.ServicioIngestaCalorica;

public class ProPri extends JFrame implements ActionListener {

private JButton calcularIMCButton;

private JButton calcularAguaButton;
private JButton registrarIngestaButton;
private JButton salirButton;
private JLabel opcionesLabel;
private ServicioDeIMC servicioIMC;
private ConsumoDeAgua servicioConsumoAgua;
private ServicioIngestaCalorica servicioIngestaCalorica;

public ProPri() {
servicioIMC = new ServicioDeIMC();
servicioConsumoAgua = new ConsumoDeAgua();
servicioIngestaCalorica = new ServicioIngestaCalorica();

setTitle("Programa Principal");
setSize(300, 250);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setLocationRelativeTo(null);

JPanel panel = new JPanel();

panel.setLayout(null);

opcionesLabel = new JLabel("Estas son las distintas opciones:");

opcionesLabel.setBounds(20, 10, 250, 20);
panel.add(opcionesLabel);

calcularIMCButton = new JButton("Calcular IMC");

calcularIMCButton.setBounds(20, 40, 250, 30);
calcularIMCButton.addActionListener(this);
panel.add(calcularIMCButton);

calcularAguaButton = new JButton("Calcular Agua");

calcularAguaButton.setBounds(20, 80, 250, 30);
calcularAguaButton.addActionListener(this);
panel.add(calcularAguaButton);

registrarIngestaButton = new JButton("Registrar Ingesta");

 15

registrarIngestaButton.setBounds(20, 120, 250, 30);

registrarIngestaButton.addActionListener(this);
panel.add(registrarIngestaButton);

salirButton = new JButton("Salir");

salirButton.setBounds(20, 160, 250, 30);
salirButton.addActionListener(this);
panel.add(salirButton);

add(panel);
setVisible(true);
}

public void actionPerformed(ActionEvent e) {

if (e.getSource() == calcularIMCButton) {
calcularIMC();
} else if (e.getSource() == calcularAguaButton) {
calcularConsumoAgua();
} else if (e.getSource() == registrarIngestaButton) {
registrarIngestaCalorica();
} else if (e.getSource() == salirButton) {
System.exit(0);
}
}

private void calcularIMC() {

double altura = Double.parseDouble(JOptionPane.showInputDialog("Ingrese su altura en
metros:"));
double peso = Double.parseDouble(JOptionPane.showInputDialog("Ingrese su peso en
kilogramos:"));

double imc = servicioIMC.calcularIMC(peso, altura);

String clasificacionIMC = servicioIMC.clasificarIMC(imc);
String recomendacionIMC = servicioIMC.obtenerRecomendacion(imc);
String riesgoSalud = servicioIMC.evaluarRiesgoSalud(imc);

StringBuilder mensaje = new StringBuilder("Su IMC es: ");

mensaje.append(imc)
.append("\nClasificación del IMC: ").append(clasificacionIMC)
.append("\nRecomendación: ").append(recomendacionIMC)
.append("\nRiesgo de salud: ").append(riesgoSalud);

JOptionPane.showMessageDialog(this, mensaje.toString());
}

private void calcularConsumoAgua() {

double peso = Double.parseDouble(JOptionPane.showInputDialog("Ingrese su peso en
kilogramos:"));
String nivelActividad = JOptionPane.showInputDialog("Ingrese su nivel de actividad física (bajo,
medio, alto):");
 16

double temperatura = Double.parseDouble(JOptionPane.showInputDialog("Ingrese la

temperatura ambiente en grados Celsius:"));
int numeroDeTomas = Integer.parseInt(JOptionPane.showInputDialog("Ingrese el número de
tomas de agua por día:"));

double consumoAguaBase = servicioConsumoAgua.calcularConsumoAgua(peso,

nivelActividad);
double consumoAguaAjustado =
servicioConsumoAgua.ajustarConsumoPorTemperatura(consumoAguaBase, temperatura);
double[] consumoAguaTomas =
servicioConsumoAgua.dividirConsumoDiario(consumoAguaAjustado, numeroDeTomas);
String recomendacionHidratacion =
servicioConsumoAgua.obtenerRecomendacionHidratacion(nivelActividad);

StringBuilder mensaje = new StringBuilder("Consumo de agua recomendado: ");

mensaje.append(consumoAguaAjustado).append(" litros por día.");
mensaje.append("\nNúmero de tomas de agua recomendadas: ").append(numeroDeTomas);
mensaje.append("\nCantidad de agua por toma: ");
for (int i = 0; i < consumoAguaTomas.length; i++) {
mensaje.append("\nToma ").append(i + 1).append(":
").append(consumoAguaTomas[i]).append(" litros");
}
mensaje.append("\n").append(recomendacionHidratacion);

JOptionPane.showMessageDialog(this, mensaje.toString());
}

private void registrarIngestaCalorica() {

List<Integer> caloriasConsumidas = new ArrayList<>();
int cantidadAlimentos = Integer.parseInt(JOptionPane.showInputDialog("Ingrese la cantidad de
alimentos consumidos hoy:"));

for (int i = 0; i < cantidadAlimentos; i++) {

int calorias = Integer.parseInt(JOptionPane.showInputDialog("Ingrese las calorías del alimento
" + (i + 1) + ":"));
caloriasConsumidas.add(calorias);
}

ServicioIngestaCalorica servicioIngestaCalorica = new ServicioIngestaCalorica();

int totalCaloriasConsumidas =
servicioIngestaCalorica.calcularCaloriasTotales(caloriasConsumidas);
JOptionPane.showMessageDialog(this, "Total de calorías consumidas: " +
totalCaloriasConsumidas);

int edad = Integer.parseInt(JOptionPane.showInputDialog("Ingrese su edad:"));

String sexo = JOptionPane.showInputDialog("Ingrese su sexo (masculino/femenino):");
double altura = Double.parseDouble(JOptionPane.showInputDialog("Ingrese su altura en
metros:"));
 17

double peso = Double.parseDouble(JOptionPane.showInputDialog("Ingrese su peso en

kilogramos:"));
String nivelActividad = JOptionPane.showInputDialog("Ingrese su nivel de actividad física (bajo,
medio, alto):");

int caloriasRecomendadas = servicioIngestaCalorica.estimarCaloriasRecomendadas(edad, sexo,

peso, altura, nivelActividad);
double porcentajeIngesta =
servicioIngestaCalorica.calcularPorcentajeIngestaRecomendada(totalCaloriasConsumidas,
caloriasRecomendadas);
String recomendacionIngesta =
servicioIngestaCalorica.obtenerRecomendacionIngestaCalorica(porcentajeIngesta);

JOptionPane.showMessageDialog(this, "Calorías recomendadas por día: " +

caloriasRecomendadas
+ "\nPorcentaje de la ingesta calórica recomendada consumida: " +
porcentajeIngesta + "%"
+ "\n" + recomendacionIngesta);
}

public static void main(String[] args) {

new ProPri();
}
}

Servicio del IMC

package serviciodeimc;

public class ServicioDeIMC {

public ServicioDeIMC (){

}

public double calcularIMC(double peso, double altura) {

return peso / (altura * altura);
}

public String clasificarIMC(double imc) {

if (imc < 18.5) {
return "Bajo peso";
} else if (imc >= 18.5 && imc < 24.9) {
return "Normal";
} else if (imc >= 25 && imc < 29.9) {
return "Sobrepeso";
} else {
return "Obesidad";
}
}

public String obtenerRecomendacion(double imc) {

 18

if (imc < 18.5) {

return "Se recomienda ganar peso mediante una dieta equilibrada.";
} else if (imc >= 18.5 && imc < 24.9) {
return "Mantén tu peso actual con una dieta saludable y ejercicio regular.";
} else if (imc >= 25 && imc < 29.9) {
return "Se recomienda perder peso mediante una dieta controlada y ejercicio.";
} else {
return "Se recomienda consultar a un profesional de la salud para perder peso de manera
segura.";
}
}

public String evaluarRiesgoSalud(double imc) {

if (imc < 18.5) {
return "Riesgo de desnutrición y problemas de salud asociados.";
} else if (imc >= 18.5 && imc < 24.9) {
return "Riesgo bajo de problemas de salud relacionados con el peso.";
} else if (imc >= 25 && imc < 29.9) {
return "Aumento del riesgo de problemas de salud como enfermedades cardiovasculares.";
} else {
return "Alto riesgo de problemas de salud graves como diabetes tipo 2 y enfermedades del
corazón.";
}
}
}

Consumo de Agua

package consumodeagua;

public class ConsumoDeAgua {

public ConsumoDeAgua() {
}

public double calcularConsumoAgua(double peso, String nivelActividad) {

double baseAgua = peso * 0.035;
switch (nivelActividad.toLowerCase()) {
case "bajo":
return baseAgua;
case "medio":
return baseAgua * 1.2;
case "alto":
return baseAgua * 1.5;
default:
return baseAgua;
}
}

public double ajustarConsumoPorTemperatura(double consumoBase, double temperatura) {

 19

if (temperatura > 30) {

return consumoBase * 1.2;
} else if (temperatura < 10) {
return consumoBase * 0.8;
} else {
return consumoBase;
}
}

public double[] dividirConsumoDiario(double consumoTotal, int numeroDeTomas) {

double[] tomas = new double[numeroDeTomas];
double consumoPorToma = consumoTotal / numeroDeTomas;
for (int i = 0; i < numeroDeTomas; i++) {
tomas[i] = consumoPorToma;
}
return tomas;
}

public String obtenerRecomendacionHidratacion(String nivelActividad) {

switch (nivelActividad.toLowerCase()) {
case "bajo":
return "Recuerda hidratarte, incluso si no sientes sed.";
case "medio":
return "Asegúrate de beber agua regularmente a lo largo del día.";
case "alto":
return "Es importante mantenerse bien hidratado debido a tu alto nivel de actividad.";
default:
return "Mantén una botella de agua contigo y bebe frecuentemente.";
}
}
}

Servicio de Ingesta Calórica

package servicioingestacalorica;
import java.util.List;

public class ServicioIngestaCalorica {

public ServicioIngestaCalorica() {
}

public int calcularCaloriasTotales(List<Integer> caloriasConsumidas) {

int totalCalorias = 0;
for (int calorias : caloriasConsumidas) {
totalCalorias += calorias;
}
return totalCalorias;
}

public int estimarCaloriasRecomendadas(int edad, String sexo, double peso, double altura, String
 20

nivelActividad) {
double tmb;
if (sexo.equalsIgnoreCase("masculino")) {
tmb = 88.36 + (13.4 * peso) + (4.8 * altura * 100) - (5.7 * edad);
} else {
tmb = 447.6 + (9.2 * peso) + (3.1 * altura * 100) - (4.3 * edad);
}

switch (nivelActividad.toLowerCase()) {
case "bajo":
return (int) (tmb * 1.2);
case "medio":
return (int) (tmb * 1.375);
case "alto":
return (int) (tmb * 1.55);
default:
return (int) tmb;
}
}

public double calcularPorcentajeIngestaRecomendada(int caloriasTotales, int

caloriasRecomendadas) {
return (caloriasTotales * 100.0) / caloriasRecomendadas;
}

public String obtenerRecomendacionIngestaCalorica(double porcentajeIngesta) {

if (porcentajeIngesta < 100) {
return "Intenta consumir más alimentos ricos en nutrientes para alcanzar tus necesidades
calóricas.";
} else if (porcentajeIngesta > 100) {
return "Es posible que estés consumiendo demasiadas calorías, considera hacer ajustes en tu
dieta.";
} else {
return "Tu ingesta calórica está en un nivel saludable. ¡Sigue así!";
}
}
}
 21

Código completo en Imagen:

22
23
24
25
 26

Resultados:
27
 28

Conclusión:
En conclusión, en este proyecto se desarrolló un programa en Java utilizando tres librerías
distintas y una clase principal muestra claramente los beneficios de la programación
modular. El programa aborda tres áreas: cálculo del Índice de Masa Corporal (IMC),
seguimiento del consumo de agua, y gestión de la ingesta de calorías. Cada librería contiene
al menos cuatro métodos distintos, además del constructor.
La eficiencia en el desarrollo se incrementa significativamente al reutilizar código
existente, lo que acelera el proceso de desarrollo. La clase principal del programa coordina
la interacción entre las diferentes librerías, captura datos del usuario y presenta los
resultados de manera integrada, proporcionando una interfaz clara y coherente para el
usuario. En términos de implementación, cada librería ofrece métodos especializados que
permiten una gestión eficaz de sus respectivas áreas. Por otro lado, En términos de
implementación, la clase principal puede invocar métodos de las librerías de manera
ordenada, gestionando la entrada y salida de datos y asegurando que cada librería opere de
manera autónoma pero coordinada.
En resumen, la utilización de componentes y librerías modulares en el desarrollo de este
programa en Java demuestra cómo esta estrategia puede mejorar considerablemente la
mantenibilidad, escalabilidad y eficiencia del software. Al encapsular funcionalidades
específicas en librerías independientes, se logra un desarrollo más estructurado y ordenado,
lo que facilita la incorporación de nuevas características y ofrece una base sólida para
futuras mejoras y expansiones del programa. Este enfoque modular no solo optimiza el
proceso de desarrollo, sino que también garantiza que el software resultante sea robusto,
fácil de mantener y adaptable a las necesidades cambiantes de los usuarios.