Proyecto Integrador

Paso 0 – Antes de empezar

¡Haz un fork del repositorio!
Dirígete a:

https://github.com/jfinfocesde/25_proyecto_integrador.git

y pulsa el botón Fork (esquina superior derecha).
Tras ello clónalo en tu equipo:

git clone https://github.com/TU-USUARIO/25_proyecto_integrador.git
cd 25_proyecto_integrador

Grupos

https://docs.google.com/spreadsheets/d/1cwSEZYqUuOViCpCJKUcg7sM7T-In5SFQ5dwQmNjaiYE/edit?usp=sharing

Indicaciones para el Proyecto Integrador de Java: Lógica de Programación

Instrucciones Generales

Cada grupo debe desarrollar un proyecto integrador en Java que demuestre la aplicación de los conceptos de lógica de programación vistos en clase. El proyecto consistirá en la creación de mínimo 5 algoritmos basados en un tema o área de conocimiento seleccionado por el grupo, como por ejemplo Calculadoras y Conversores. Los algoritmos deben abordar todos los temas de clase indicados y seguir las especificaciones detalladas a continuación.

Temas a Abordar

Los algoritmos deben incorporar los siguientes conceptos de programación en Java:

Imprimir y leer datos de consola: Uso de System.out.println() y clases como Scanner para entrada de datos.
Declaración de variables y constantes: Uso de variables (int, double, String, etc.) y constantes (final).
Operadores:
- Aritméticos: +, -, *, /, %.
- Asignación: =, +=, -=, etc.
- Comparación: ==, !=, >, <, >=, <=.
- Lógicos: &&, ||, !.
Tipos de datos:
- Primitivos: int, double, boolean, char, etc.
- No primitivos: String, Array, ArrayList, etc.
Estructuras de control condicionales: if, else if, else, switch.
Estructuras de control repetitivas (bucles): for, while, do-while.
Estructuras de datos: Uso de Array y ArrayList para almacenar y manipular datos.
Métodos:
- Sin retorno (void).
- Con retorno (retornando tipos como int, double, String, etc.).
- Con parámetros y sin parámetros.

Requisitos del Proyecto

Selección del Tema:
- Cada grupo debe elegir un tema o área de conocimiento para desarrollar los algoritmos. Ejemplo: Calculadoras y Conversores (puede ser conversión de unidades, cálculos matemáticos, financieros, estadísticos, etc.).
- Otros ejemplos de temas: Gestión de inventarios, sistemas de votación, cálculos geométricos, simuladores de juegos, etc.
Desarrollo de Algoritmos:
- Crear mínimo 5 algoritmos relacionados con el tema seleccionado.
- Cada algoritmo debe:
  - Ser implementado en Java.
  - Abordar todos los temas de clase mencionados (puede ser en conjunto entre los algoritmos, no necesariamente cada algoritmo debe incluir todos los temas).
  - Ser funcional y cumplir con un propósito claro dentro del tema elegido.
  - Incluir comentarios en el código para explicar su lógica.
Estructura del Repositorio:
- Utilizar el fork GitHub.
- Incluir un archivo Readme.md con la estructura especificada.
- Cada algoritmo debe estar en un archivo Java independiente (o en un solo archivo con métodos claramente separados, según prefiera el grupo).
- Incluir un archivo ejecutable principal (Main.java) que integre todos los algoritmos (por ejemplo, un menú interactivo para seleccionar y ejecutar cada algoritmo).
Archivo Readme.md: El archivo debe seguir la siguiente estructura:

# Proyecto Integrador de Java: [Nombre del Tema]

## Integrantes del Equipo
- Nombre 1
- Nombre 2
- Nombre 3
- (Agregar todos los integrantes)

## Introducción
Breve descripción del proyecto, el tema seleccionado y su relevancia. Explicar cómo los algoritmos desarrollados resuelven problemas relacionados con el tema.

## Objetivo General
Describir el propósito principal del proyecto (por ejemplo, "Desarrollar una serie de algoritmos en Java que permitan realizar cálculos y conversiones de unidades de manera eficiente").

## Objetivos Específicos
- Objetivo 1 (por ejemplo, "Implementar un conversor de temperaturas usando estructuras condicionales").
- Objetivo 2 (por ejemplo, "Utilizar ArrayList para almacenar un historial de conversiones").
- Objetivo 3 (por ejemplo, "Crear métodos reutilizables para cálculos repetitivos").
- (Mínimo 3 objetivos específicos).

## Descripción de los Algoritmos

### Algoritmo 1: [Nombre del Algoritmo]
- **Descripción**: Explicar qué hace el algoritmo y su propósito dentro del proyecto.
- **Temas de Clase Abordados**: Listar los temas de clase utilizados (por ejemplo, "Imprimir/leer datos de consola, estructuras condicionales, métodos con retorno").
- **Código de Ejemplo** (opcional): Incluir un fragmento representativo del código.

### Algoritmo 2: [Nombre del Algoritmo]
- **Descripción**: ...
- **Temas de Clase Abordados**: ...

### Algoritmo 3: [Nombre del Algoritmo]
- **Descripción**: ...
- **Temas de Clase Abordados**: ...

### Algoritmo 4: [Nombre del Algoritmo]
- **Descripción**: ...
- **Temas de Clase Abordados**: ...

### Algoritmo 5: [Nombre del Algoritmo]
- **Descripción**: ...
- **Temas de Clase Abordados**: ...

## Conclusiones
Resumir los aprendizajes obtenidos, los retos enfrentados y cómo el proyecto ayudó a consolidar los conocimientos de programación en Java.

Ejemplo de Proyecto: Calculadoras y Conversores

Tema: Desarrollo de un sistema de calculadoras y conversores de unidades.

Ejemplo de Algoritmos:

Conversor de Temperaturas:
- Descripción: Convierte temperaturas entre Celsius, Fahrenheit y Kelvin.
- Temas: Entrada/salida por consola (Scanner, System.out), variables, operadores aritméticos, estructuras condicionales (if-else o switch), métodos con retorno.
Calculadora de Promedios:
- Descripción: Calcula el promedio de una lista de números ingresados por el usuario.
- Temas: Bucles (for o while), Array o ArrayList, operadores aritméticos, entrada/salida.
Conversor de Monedas:
- Descripción: Convierte entre diferentes monedas usando tasas de cambio predefinidas.
- Temas: Constantes (final), métodos con parámetros, operadores aritméticos, entrada/salida.
Historial de Conversiones:
- Descripción: Almacena y muestra un historial de conversiones realizadas.
- Temas: ArrayList, bucles, entrada/salida, métodos sin retorno.
Calculadora de Área Geométrica:
- Descripción: Calcula el área de figuras geométricas (círculo, triángulo, rectángulo) según la elección del usuario.
- Temas: Estructuras condicionales (switch), métodos con retorno, operadores lógicos, entrada/salida.

Ejemplo de Código (Algoritmo 1 - Conversor de Temperaturas):

import java.util.Scanner;

public class ConversorTemperaturas {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("Seleccione unidad de entrada (1: Celsius, 2: Fahrenheit, 3: Kelvin): ");
        int opcion = scanner.nextInt();
        System.out.println("Ingrese la temperatura: ");
        double temperatura = scanner.nextDouble();

        switch (opcion) {
            case 1:
                System.out.println("Fahrenheit: " + celsiusToFahrenheit(temperatura));
                System.out.println("Kelvin: " + celsiusToKelvin(temperatura));
                break;
            case 2:
                System.out.println("Celsius: " + fahrenheitToCelsius(temperatura));
                System.out.println("Kelvin: " + fahrenheitToKelvin(temperatura));
                break;
            case 3:
                System.out.println("Celsius: " + kelvinToCelsius(temperatura));
                System.out.println("Fahrenheit: " + kelvinToFahrenheit(temperatura));
                break;
            default:
                System.out.println("Opción inválida");
        }
        scanner.close();
    }

    public static double celsiusToFahrenheit(double celsius) {
        return (celsius * 9 / 5) + 32;
    }

    public static double celsiusToKelvin(double celsius) {
        return celsius + 273.15;
    }

    public static double fahrenheitToCelsius(double fahrenheit) {
        return (fahrenheit - 32) * 5 / 9;
    }

    public static double fahrenheitToKelvin(double fahrenheit) {
        return (fahrenheit - 32) * 5 / 9 + 273.15;
    }

    public static double kelvinToCelsius(double kelvin) {
        return kelvin - 273.15;
    }

    public static double kelvinToFahrenheit(double kelvin) {
        return (kelvin - 273.15) * 9 / 5 + 32;
    }
}