alberto/Proyecto_1_Parqueo
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Browse Source
This commit is contained in:
alberto
2026-04-01 21:33:33 +02:00
parent 7f4f8f475b
commit a9eb929b44
9 changed files with 741 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

25
NetBeans_Proyecto_1_Parqueo/src/main/java/parqueo/Automovil.java Normal file
View File

@@ -0,0 +1,25 @@
package parqueo;
public class Automovil extends Vehiculo {
//constructor
public Automovil(String placa) {
super(placa);
}
@Override
public int getTarifaPorHora() {
return 600;
}
@Override
public int getTarifaPorDia() {
return 5000;
}
@Override
public String getNombre(){
return "Automovil";
}
}

112
NetBeans_Proyecto_1_Parqueo/src/main/java/parqueo/CalculoTarifa.java Normal file
View File

@@ -0,0 +1,112 @@
package parqueo;
import java.time.LocalDateTime;
import java.time.Duration;
public class CalculoTarifa {
//originalmente calculaba el monto total aquí y en Main, pero codex sugirió mantener cálculos fuera de main. El prompt fué: "Remove the duplicate and adjust the text."
public static class DetalleCobro {
private long minutos;
private int tarifaAplicada;
private long unidCobro;
private int subtotal;
private int descuento;
private int total;
public DetalleCobro(long minutos, int tarifaAplicada, long unidCobro, int subtotal, int descuento, int total) {
this.minutos = minutos;
this.tarifaAplicada = tarifaAplicada;
this.unidCobro = unidCobro;
this.subtotal = subtotal;
this.descuento = descuento;
this.total = total;
}
public long getMinutos() {
return minutos;
}
public int getTarifaAplicada() {
return tarifaAplicada;
}
public long getUnidCobro() {
return unidCobro;
}
public int getSubtotal() {
return subtotal;
}
public int getDescuento() {
return descuento;
}
public int getTotal() {
return total;
}
}
public int calcularMonto(TiqueteParqueo t) {
DetalleCobro detalle = calcularDetalle(t);
t.setMontoTotal(detalle.getTotal());
return detalle.getTotal();
}
public DetalleCobro calcularDetalle(TiqueteParqueo t) {
long minutos = calcularMinCobro(t);
int tarifa = obtenerTarifa(t);
long unidades = getUnidadCobro(minutos, t.getModalidad());
int subtotal = (int) (unidades * tarifa);
int descuento = calcularDescuento(t.getModalidad(), unidades, subtotal);
int total = subtotal - descuento;
return new DetalleCobro(minutos, tarifa, unidades, subtotal, descuento, total);
}
// Obtiene la tarifa segun modalidad
private int obtenerTarifa(TiqueteParqueo t) {
TiqueteParqueo.TipoServicio modalidad = t.getModalidad();
if (modalidad == TiqueteParqueo.TipoServicio.POR_HORA) {
return t.getVehiculo().getTarifaPorHora();
}
if (modalidad == TiqueteParqueo.TipoServicio.POR_DIA) {
return t.getVehiculo().getTarifaPorDia();
}
throw new IllegalArgumentException("Tipo de vehículo o modalidad inválidos.");
}
private long calcularMinCobro(TiqueteParqueo t) {
LocalDateTime horaEntrada = t.getHoraEntrada();
LocalDateTime horaSalida = t.getHoraSalida();
if (horaSalida.isBefore(horaEntrada)) { //excepción recomendada por codex
throw new IllegalArgumentException("La hora de salida no puede ser anterior a la hora de entrada.");
}
long minutos = Duration.between(horaEntrada, horaSalida).toMinutes();
if (minutos == 0) {
return 1;
}
return minutos;
}
private long getUnidadCobro(long minutos, TiqueteParqueo.TipoServicio modalidad) {
if (modalidad == TiqueteParqueo.TipoServicio.POR_HORA) {
return (minutos + 59) / 60;
}
return (minutos + 1439) / 1440;
}
private int calcularDescuento(TiqueteParqueo.TipoServicio modalidad, long unidades, int subtotal) {
if (modalidad == TiqueteParqueo.TipoServicio.POR_HORA && unidades > 8) {
return subtotal * 10 / 100;
}
return 0;
}
}

24
NetBeans_Proyecto_1_Parqueo/src/main/java/parqueo/Camion.java Normal file
View File

@@ -0,0 +1,24 @@
package parqueo;
public class Camion extends Vehiculo {
public Camion (String placa){
super(placa);
}
@Override
public int getTarifaPorHora() {
return 600;
}
@Override
public int getTarifaPorDia() {
return 5000;
}
@Override
public String getNombre(){
return "Camión";
}
}

95
NetBeans_Proyecto_1_Parqueo/src/main/java/parqueo/GestorParqueo.java Normal file
View File

@@ -0,0 +1,95 @@
package parqueo;
import java.util.ArrayList;
import java.time.LocalDate;
public class GestorParqueo {
private static final int MAX_VEHICULOS = 10;
private ArrayList<Vehiculo> vehiculosParqueados;
private ArrayList<TiqueteParqueo> tiquetes;
public GestorParqueo() {
this.vehiculosParqueados = new ArrayList<Vehiculo>();
this.tiquetes = new ArrayList<TiqueteParqueo>();
}
public boolean registrarIngreso(TiqueteParqueo nuevoTiquete) {
if (this.vehiculosParqueados.size() < MAX_VEHICULOS
&& !existePlaca(nuevoTiquete.getVehiculo().getPlaca())) {
this.vehiculosParqueados.add(nuevoTiquete.getVehiculo());
this.tiquetes.add(nuevoTiquete);
return true;
}
if (this.vehiculosParqueados.size() > 4){
System.out.println("Aviso: quedan " + espaciosDisponibles() + "espacios disponibles.");
}
return false;
}
public boolean existePlaca(String placa) {
for (Vehiculo vehiculo : this.vehiculosParqueados) {
if (vehiculo.getPlaca().equals(placa)) {
return true;
}
}
return false;
}
public int espaciosDisponibles() {
return MAX_VEHICULOS - this.vehiculosParqueados.size();
}
public int getCapacidadMaxima() {
return MAX_VEHICULOS;
}
public boolean estaVacio() {
return this.vehiculosParqueados.isEmpty();
}
public TiqueteParqueo buscarTiqueteAbierto(String placa) {
for (TiqueteParqueo tiquete : this.tiquetes) {
if (tiquete.getVehiculo().getPlaca().equals(placa) && tiquete.getHoraSalida() == null) {
return tiquete;
}
}
return null;
}
public boolean registrarSalida(String placa) {
boolean vehiculoEliminado = false;
for (int i = 0; i < this.vehiculosParqueados.size(); i++) {
if (this.vehiculosParqueados.get(i).getPlaca().equals(placa)) {
this.vehiculosParqueados.remove(i);
vehiculoEliminado = true;
break;
}
}
return vehiculoEliminado;
}
public Vehiculo buscarPlaca(String placa) {
for (Vehiculo vehiculo : this.vehiculosParqueados) {
if (vehiculo.getPlaca().equals(placa)) {
return vehiculo;
}
}
return null;
}
public ArrayList<TiqueteParqueo> getTiquetesDia(LocalDate fecha) {
ArrayList<TiqueteParqueo> resultado = new ArrayList<TiqueteParqueo>();
for (TiqueteParqueo tiquete : this.tiquetes) {
if (tiquete.getHoraEntrada() != null
&& tiquete.getHoraEntrada().toLocalDate().equals(fecha)) {
resultado.add(tiquete);
}
}
return resultado;
}
}

279
NetBeans_Proyecto_1_Parqueo/src/main/java/parqueo/Main.java Normal file
View File

@@ -0,0 +1,279 @@
/*
UNIVERSIDAD ESTATAL A DISTANCIA
ESCUELAS DE CIENCIAS EXACTAS Y NATURALES
CATEDRA TECNOLOGÍA DE SISTEMAS
ANDRES ALBERTO SANCHEZ TREJOS
GRUPO 09
TUTOR: HERSANN FONSECA QUIRÓS
PROGRAMACION INTERMEDIA 00824
Proyecto #1
IC2026
Bibliografía
Deitel, P.J.D. H. (2021). Cómo Programar En Java. Pearson HispanoAmerica Contenido. https://bookshelf.vitalsource.com/books/9786073255400
https://www.w3schools.com/java/
CODEX: se usó para generalmente para revisar la eficacia de las cláses y métodos.
El prompt generalmente utilizado fue "revisa esta método/función" o fué utilizado .
*/
package parqueo;
import java.util.Scanner;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
public class Main {
private static final DateTimeFormatter fechaHora = DateTimeFormatter.ofPattern("dd/MM/yyyy HH:mm");
public static void main(String[] args) throws Exception {
GestorParqueo gestorParqueo = new GestorParqueo();
Scanner entrada = new Scanner(System.in);
int opcion = 0;
System.out.println("=================================");
System.out.println("Bienvenido al sistema de parqueo");
System.out.println("=================================");
LocalDate fechaAc = LocalDate.now();
System.out.println("Fecha actual: " + fechaAc);
while (opcion != 5) {
System.out.println("1. Registrar ingreso de vehículo");
System.out.println("2. Registrar salida de vehículo");
System.out.println("3. Consultar espacios disponibles");
System.out.println("4. Ver reportes del día");
System.out.println("5. Salir");
System.out.println("Seleccione una opción:");
opcion = intValida(entrada);
switch (opcion) {
case 1:
TiqueteParqueo nuevoTiquete = registrarIngreso(entrada, gestorParqueo);
if (nuevoTiquete != null) {
if (gestorParqueo.registrarIngreso(nuevoTiquete)) {
System.out.println("Ingreso registrado correctamente.");
System.out.println("Espacios disponible: " + gestorParqueo.espaciosDisponibles() + "/10");
if (gestorParqueo.espaciosDisponibles() <= 5) {
System.err.println("Advertencia: Se ha alcanzado el 50% de capacidad máxima");
}
if (gestorParqueo.espaciosDisponibles() == 10) {
System.out.println("Advertencia: Se ha alcanzado la capacidad máxima 10/10.");
}
} else {
System.out.println("No hay espacios disponibles.");
}
}
regresarMenuPrincipal(entrada);
break;
case 2:
if (!gestorParqueo.estaVacio()) {
registrarSalida(entrada, gestorParqueo);
} else {
System.out.println("No hay vehiculos registrados.");
}
regresarMenuPrincipal(entrada);
break;
case 3:
System.out.println("Espacios disponibles: " + gestorParqueo.espaciosDisponibles());
regresarMenuPrincipal(entrada);
break;
case 4:
mostrarMenuReportes(entrada, gestorParqueo);
regresarMenuPrincipal(entrada);
break;
case 5:
System.out.println("Saliendo del sistema de parqueo.");
break;
default:
System.out.println("Opción inválida. Por favor, seleccione una opción válida.");
regresarMenuPrincipal(entrada);
break;
}
}
entrada.close();
}
private static TiqueteParqueo registrarIngreso(Scanner entrada, GestorParqueo gestorParqueo) {
String placa = placaValida(entrada);
if (gestorParqueo.existePlaca(placa)) {
System.out.println("La placa ingresada ya está registrada.");
return null;
}
int tipo = -1;
boolean tipoValido = false;
while (!tipoValido) {
System.out.println("Ingrese el tipo de vehículo (1 para Automóvil, 2 para Motocicleta, 3 para Camión):");
tipo = intValida(entrada);
if (tipo >= 1 && tipo <= 3) {
tipoValido = true;
} else {
System.out.println("Opción inválida. Por favor, seleccione una opción válida.");
}
}
TiqueteParqueo.TipoServicio modalidad = setModalidad(entrada);
try {
Vehiculo vehiculo = switch (tipo) {
case 1 ->
new Automovil(placa);
case 2 ->
new Motocicleta(placa);
case 3 ->
new Camion(placa);
default ->
throw new IllegalArgumentException("Tipo inválido.");
};
return new TiqueteParqueo(vehiculo, LocalDateTime.now(), modalidad);
} catch (IllegalArgumentException e) {
System.out.println(e.getMessage());
return null;
}
}
private static void registrarSalida(Scanner entrada, GestorParqueo gestorParqueo) {
String placa = placaValida(entrada);
TiqueteParqueo tiquete = gestorParqueo.buscarTiqueteAbierto(placa);
if (tiquete == null) {
System.out.println("Placa no se encuentra registrada en el sistema.");
} else {
tiquete.setHoraSalida(LocalDateTime.now());
CalculoTarifa calculadora = new CalculoTarifa();
CalculoTarifa.DetalleCobro detalle = calculadora.calcularDetalle(tiquete);
int monto = detalle.getTotal();
tiquete.setMontoTotal(monto);
gestorParqueo.registrarSalida(placa);
String horaEntrada = tiquete.getHoraEntrada().format(fechaHora);
String horaSalida = tiquete.getHoraSalida().format(fechaHora);
double tiempoHoras = detalle.getMinutos() / 60.0;
System.out.println("****************************************");
System.out.println("RECIBO DE PARQUEO");
System.out.println("****************************************");
System.out.println("Placa: " + tiquete.getVehiculo().getPlaca());
System.out.println("Tipo: " + tiquete.getVehiculo().getNombre());
System.out.println("Tipo de servicio: " + tipoServicioTexto(tiquete.getModalidad()));
System.out.println("Hora de entrada: " + horaEntrada);
System.out.println("Hora de salida: " + horaSalida);
System.out.println("Tiempo de permanencia (horas): " + String.format("%.2f", tiempoHoras));
if (tiquete.getModalidad() == TiqueteParqueo.TipoServicio.POR_HORA) {
System.out.println("Costo por hora: CRC " + detalle.getTarifaAplicada());
} else {
System.out.println("Costo por hora: No aplica (servicio por día)");
}
System.out.println("Subtotal: CRC " + detalle.getSubtotal());
if (detalle.getDescuento() > 0) {
System.out.println("Descuento: CRC " + detalle.getDescuento());
} else {
System.out.println("Descuento: No aplica");
}
System.out.println("========================================");
System.out.println("TOTAL A PAGAR: CRC " + monto);
System.out.println("========================================");
System.out.println("Gracias por usar nuestros servicios");
}
}
private static void mostrarMenuReportes(Scanner entrada, GestorParqueo gestorParqueo) {
ReporteParqueo reporteParqueo = new ReporteParqueo();
int opcionReporte = 0;
while (opcionReporte != 4) {
System.out.println("++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++");
System.out.println("+ Menú de reportes del día +");
System.out.println("++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++");
System.out.println("1. Listado de vehículos");
System.out.println("2. Total recaudado por tipo de servicio");
System.out.println("3. Estadísticas básicas de uso del parqueo");
System.out.println("4. Volver al menú principal");
System.out.println("Seleccione una opción:");
opcionReporte = intValida(entrada);
switch (opcionReporte) {
case 1:
reporteParqueo.vehiculosDia(gestorParqueo, LocalDate.now());
break;
case 2:
reporteParqueo.totalUtilServicio(gestorParqueo, LocalDate.now());
break;
case 3:
reporteParqueo.estadisticasBasicas(gestorParqueo, LocalDate.now());
break;
case 4:
System.out.println("Regresando al menú principal.");
break;
default:
System.out.println("Opción inválida. Por favor, seleccione una opción válida.");
break;
}
}
}
// define el tipo de servicio (modalida por dia o por hora)
private static TiqueteParqueo.TipoServicio setModalidad(Scanner entrada) {
int modalidad = -1;
while (modalidad != 1 && modalidad != 2) {
System.out.println("Seleccione modalidad de cobro (1 por hora, 2 por día):");
modalidad = intValida(entrada);
if (modalidad != 1 && modalidad != 2) {
System.out.println("Opción inválida. Por favor, seleccione una opción válida.");
}
}
if (modalidad == 1) {
return TiqueteParqueo.TipoServicio.POR_HORA;
}
return TiqueteParqueo.TipoServicio.POR_DIA;
}
private static int intValida(Scanner entrada) {
int opcion = -1;
try {
opcion = Integer.parseInt(entrada.nextLine().trim());
} catch (NumberFormatException e) {
System.out.println("Error: Entrada inválida. Por favor, ingrese un número entero.");
}
return opcion;
}
private static void regresarMenuPrincipal(Scanner entrada) {
System.out.println("Presione Enter para volver al menú principal...");
entrada.nextLine();
}
private static String placaValida(Scanner entrada) {
String placa = "";
boolean placaValida = false;
while (!placaValida) {
System.out.println("Ingrese la placa del vehículo (en formato ABC123):");
placa = entrada.nextLine().trim().toUpperCase();
if (placa.isEmpty()) {
System.out.println("La placa no puede estar vacía.");
} else if (!Vehiculo.esPlacaValida(placa)) {
System.out.println("Formato inválido. Use 3 letras y 3 números (ejemplo: ABC123).");
} else {
placaValida = true;
}
}
return placa;
}
private static String tipoServicioTexto(TiqueteParqueo.TipoServicio modalidad) {
if (modalidad == TiqueteParqueo.TipoServicio.POR_HORA) {
return "Por hora";
}
return "Por día";
}
}

23
NetBeans_Proyecto_1_Parqueo/src/main/java/parqueo/Motocicleta.java Normal file
View File

@@ -0,0 +1,23 @@
package parqueo;
public class Motocicleta extends Vehiculo {
public Motocicleta (String placa){
super(placa);
}
@Override
public int getTarifaPorHora() {
return 500;
}
@Override
public int getTarifaPorDia() {
return 3000;
}
@Override
public String getNombre(){
return "Motocicleta";
}
}

84
NetBeans_Proyecto_1_Parqueo/src/main/java/parqueo/ReporteParqueo.java Normal file
View File

@@ -0,0 +1,84 @@
package parqueo;
import java.time.LocalDate;
import java.time.Duration;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
public class ReporteParqueo {
private static final DateTimeFormatter soloFecha = DateTimeFormatter.ofPattern("dd/MM/yyyy");
public void vehiculosDia(GestorParqueo gestorParqueo, LocalDate fecha) {
ArrayList<TiqueteParqueo> tiquetes = gestorParqueo.getTiquetesDia(fecha);
String fechaFormateada = fecha.format(soloFecha);
if (tiquetes.isEmpty()) {
System.out.println("No hay vehículos registrados para la fecha: " + fechaFormateada);
return;
}
System.out.println("Vehículos que usaron el parqueo el día " + fechaFormateada + ":");
for (TiqueteParqueo tiquete : tiquetes) {
String placa = tiquete.getVehiculo().getPlaca();
String entrada = tiquete.getHoraEntrada().format(soloFecha);
String salida = "Aún parqueado";
if (tiquete.getHoraSalida() != null) {
salida = tiquete.getHoraSalida().format(soloFecha);
}
System.out.println(
"Placa: " + placa + " | Tipo: " + tiquete.getVehiculo().getNombre() + " | Entrada: " + entrada + " | Salida: " + salida);
}
}
public void totalUtilServicio(GestorParqueo gestorParqueo, LocalDate fecha) {
ArrayList<TiqueteParqueo> tiquetes = gestorParqueo.getTiquetesDia(fecha);
int totalPorHora = 0;
int totalPorDia = 0;
for (TiqueteParqueo tiquete : tiquetes) {
if (tiquete.getHoraSalida() == null) {
continue;
}
if (tiquete.getModalidad() == TiqueteParqueo.TipoServicio.POR_HORA) {
totalPorHora += tiquete.getMontoTotal();
} else {
totalPorDia += tiquete.getMontoTotal();
}
}
String fechaFormateada = fecha.format(soloFecha);
System.out.println("Total recaudado por servicio el día " + fechaFormateada + ":");
System.out.println("Servicio por hora: CRC " + totalPorHora);
System.out.println("Servicio por día: CRC " + totalPorDia);
}
public void estadisticasBasicas(GestorParqueo gestorParqueo, LocalDate fecha) {
ArrayList<TiqueteParqueo> tiquetes = gestorParqueo.getTiquetesDia(fecha);
int vehiculosAtendidos = tiquetes.size();
long minutosTotales = 0;
for (TiqueteParqueo tiquete : tiquetes) {
if (tiquete.getHoraSalida() != null) {
minutosTotales += Duration.between(tiquete.getHoraEntrada(), tiquete.getHoraSalida()).toMinutes();
}
}
double horasTotales = minutosTotales / 60.0;
int capacidad = gestorParqueo.getCapacidadMaxima();
int ocupadosActuales = capacidad - gestorParqueo.espaciosDisponibles();
double ocupacionActual = (ocupadosActuales * 100.0) / capacidad;
String fechaFormateada = fecha.format(soloFecha);
System.out.println("Estadísticas básicas del día " + fechaFormateada + ":");
System.out.println("Sumatoria de horas de uso: " + String.format("%.2f", horasTotales));
System.out.println("Cantidad de vehículos atendidos: " + vehiculosAtendidos);
System.out.println("Porcentaje de ocupación actual: " + String.format("%.2f", ocupacionActual) + "%");
}
}

65
NetBeans_Proyecto_1_Parqueo/src/main/java/parqueo/TiqueteParqueo.java Normal file
View File

@@ -0,0 +1,65 @@
package parqueo;
import java.time.LocalDateTime;
public class TiqueteParqueo {
//orginalmente dos constantes, CODEX sugirió usar enum
public enum TipoServicio {
POR_HORA,
POR_DIA
}
private Vehiculo vehiculo;
private LocalDateTime horaEntrada;
private LocalDateTime horaSalida;
private TipoServicio modalidad;
private int montoTotal;
public TiqueteParqueo(Vehiculo vehiculo, LocalDateTime horaEntrada, TipoServicio modalidad) {
this.vehiculo = vehiculo;
this.horaEntrada = horaEntrada;
this.modalidad = modalidad;
this.horaSalida = null;
this.montoTotal = 0;
}
public Vehiculo getVehiculo() {
return vehiculo;
}
public void setVehiculo(Vehiculo vehiculo) {
this.vehiculo = vehiculo;
}
public LocalDateTime getHoraEntrada() {
return horaEntrada;
}
public void setHoraEntrada(LocalDateTime horaEntrada) {
this.horaEntrada = horaEntrada;
}
public LocalDateTime getHoraSalida() {
return horaSalida;
}
public void setHoraSalida(LocalDateTime horaSalida) {
this.horaSalida = horaSalida;
}
public TipoServicio getModalidad() {
return modalidad;
}
public void setModalidad(TipoServicio modalidad) {
this.modalidad = modalidad;
}
public int getMontoTotal() {
return montoTotal;
}
public void setMontoTotal(int montoTotal) {
this.montoTotal = montoTotal;
}
}

34
NetBeans_Proyecto_1_Parqueo/src/main/java/parqueo/Vehiculo.java Normal file
View File

@@ -0,0 +1,34 @@
package parqueo;
import java.util.regex.Pattern;
public abstract class Vehiculo {
public abstract int getTarifaPorHora();
public abstract int getTarifaPorDia();
public abstract String getNombre();
private String placa;
// Constructor
public Vehiculo(String placa) {
setPlaca(placa);
}
public String getPlaca() {
return placa;
}
public void setPlaca(String placa) {
if (esPlacaValida(placa)) {
this.placa = placa;
} else {
throw new IllegalArgumentException("La placa debe tener el formato ABC123.");
}
}
public static boolean esPlacaValida(String placa) {
return Pattern.matches("[A-Z]{3}\\d{3}", placa);
}
}