1
Proyecto POO Parqueadero(mayo 2022)
Jessica Sáenz leal, Julián David salcedo Camacho, Cesar Luis Sánchez
Hernández, Sergio Andrés leal Ardila
1
Un parqueadero es un establecimiento muy grande con una
movilidad enorme de trabajo, por lo cual es importante una
administración eficiente, rápida y segura. Se busca una
I. INTRODUCCION solución donde pueda almacenar información de los vehiculos
y clientes, propietarios que harán uso del espacio ofrecido por
E n el presente documento encontrara la descripción
el establecimiento. Actualización de esta información, además
de facilitar el trabajo, registrar la entrada de vehículos ya sean
particulares diarios, que duren poco tiempo o meses y la salida
general del proyecto, iniciando por el problema, como surge,
los actores implicados En el presente documento encontrara la de estos, además de la digitalización de los propietarios de
descripción general del proyecto, iniciando por el problema, vehículos y con ello el cálculo, donde se podrá obtener cuantas
como surge, los actores implicados y los requerimientos horas estuvo el vehículo en el lugar y cuanto es el saldo por
necesarios para solucionarlo. Luego encontrara el análisis y pagar a la fecha, generando recibo de entrada y salida, con sus
solución propuesta para el problema, siempre desde una respectivos datos personales. También se podrá encontrar la
perspectiva que busca la implementación de los recursos y información del personal del parqueadero, su información
características de la programación orientada a objetos. Por básica de ubicación e identificación, el saldo en mora de los
último, los diagramas UML que serán la guía, base y propietarios de vehículos en el parqueadero.
estructura del programa solución al problema, ahí veremos la E. C. JUSTIFICACION
distribución de clases, su jerarquía, los atributos,
características, y métodos que serán las acciones posibles
dentro del programa. Como resultado habremos dado solución F. Como solución se ofrece un programa que
a un problema, abordando los requerimientos dados, de una administrara al problema planteado, ofrecemos un programa
forma organizada, documentada y poniendo en práctica la que registre, guarde y procesa la información que entra y sale
programación orientada a objetos, y los requerimientos del parqueadero, en primer lugar, tendremos el Parqueadero,
necesarios para solucionarlo. Luego encontrara el análisis y que registrara el ingreso y salida de vehículos en general, así
solución propuesta para el problema, siempre desde una como podrá informar sobre su ubicación y espacio disponible,
perspectiva que busca la implementación de los recursos y posteriormente las personas, clientes que registraran sus datos
características de la programación orientada a objetos. Por personales además de poseer la lista de vehículos que les
último, los diagramas UML que serán la guía, base y pertenece, ingresar nuevos vehículos y así mismo sacarlos del
estructura del programa solución al problema, ahí veremos la lugar.
distribución de clases, su jerarquía, los atributos,
características, y métodos que serán las acciones posibles
dentro del programa. Como resultado habremos dado solución
a un problema, abordando los requerimientos dados, de una
forma organizada, documentada y poniendo en práctica la G. D. REQUERIMIENTOS
programación orientada a objetos.
Se requiere un programa que cumpla como mínimo con las
siguientes características:
A. ABSTRACT Registro de información de los diferentes actores en
el parqueadero, con capacidad para actualizarla.
Cálculo del saldo por pagar por parte de los
The problem is the digitization of the management of a public
propietarios a la hora de retirar los vehículos.
parking lot where cars and motorcycles arrive, for all the
clients of the city than needs to save their vehicles, its Generación de los recibos de ingreso y salida de los
requirements will be, the registration of entry and exit of vehículos.
vehicles, the identification of all people, owners, and the Calculo general del estado financiero, saldo por pagar
solution will have to save information and process it, resulting y a favor del parqueadero en general.
in accounts that reflect the financial status, as well as the
payment of the payroll and the balance of the owners. Se reconocen como actores, los clientes y los vehículos, todos
harán parte del parqueadero.
B. El parqueadero: Sera un actor con características
C. identificativas como nit, ubicación, y capacidad. Mostrará su
información y el espacio disponible.
D. B. PROBLEMA Clientes: De los clientes igualmente se registrará su
información personal y una lista donde se guardará la
1
2
información de los vehículos que posea en el parqueadero. [Link] = nit;
Capas de ingresar y dar salida a sus vehículos.
Vehículos: De los vehículos, se les podrá registrar la placa y el }
momento en el que ingresan al parqueadero, también es
posible especificar el tipo de vehículo y la clase poseerá la /*El método espacioDisponible, busca en la carpeta donde son
información del costo por hora, minuto y segundo ya sea de guardados los archivos de texto que guardan el momento de
carro o moto. Hará el cálculo del tiempo en el parqueadero y ingreso de cada vehículo, y esta cantidad la resta al espacio del
costo a pagar. estacionamiento. */
public void espacioDisponible() {
try {
H. E. DIAGRAMAS UML String currentPath = new
[Link](".").getCanonicalPath();
String archivo = currentPath + "\\Vehiculos";
File carpeta = new File(archivo);
File[] lista = [Link]();
[Link]("Hay " + ([Link] -
[Link]) + " espacios disponibles.");
} catch (IOException e) {
[Link]();
}
/*En el siguiente método main, se podrá ejecutar el programa
desde el cmd, ahí se calculara el espacio disponible, ingresará
y dará salida a los autos. */
public static void main(String[] args) {
Parqueadero Castilla = new Parqueadero("Castilla", 5,
"Piedra Pintada", 1631823, 100000);
if ("ingreso".equals(args[0])) {
I. F. CODIGO Vehiculo carro1 = new Vehiculo(args[1]);
[Link]();
1) CLASES } else if ("salida".equals(args[0])) {
Vehiculo carro1 = new Vehiculo(args[1]);
[Link](args[1],
a) PARQUEADERO [Link](args[2]));
import [Link]; } else if ("espacio".equals(args[0])) {
import [Link]; [Link]();
}
public class Parqueadero { [Link]();
}
public String nombre;
private int capacidad; // Setters & Getters
public String direccion;
private int nit; public String getNombre() {
private int espacioOcupado; return nombre;
}
public Parqueadero() {
public void setNombre(String nombre) {
} [Link] = nombre;
}
public Parqueadero(String nombre, int capacidad, String
direccion, int nit, int costoMantenimiento) { public int getCapacidad() {
[Link] = nombre; return capacidad;
[Link] = capacidad; }
[Link] = direccion;
3
public void setCapacidad(int capacidad) { [Link] = [Link]();
[Link] = capacidad; [Link] = placa;
} [Link] = tipo;
public String getDireccion() { }
return direccion; /* En el metodo ingresarVehiculo se crea y modifica el archivo
} de texto que guardara como String el momento en el que
ingresa el vehículo identificado por la placa. Se tienen varias
public void setDireccion(String direccion) { veces el mismo metodo para que pueda funcionar con o sin
[Link] = direccion; parámetros. */
}
public void ingresarVehiculo() {
public int getNit() { String archivo = [Link] + ".txt";
return nit; DateTimeFormatter formatter =
} [Link]("yyyy-MM-dd HH:mm");
public void setNit(int nit) { String escrito = [Link](formatter);
[Link] = nit;
} try {
String currentPath = new
public int getEspacioOcupado() { [Link](".").getCanonicalPath();
return espacioOcupado; archivo = currentPath + "\\Vehiculos" + placa + ".txt";
} File file = new File(archivo);
if (![Link]()) {
public void setEspacioOcupado(int espacioOcupado) { [Link]();
[Link] = espacioOcupado; }
} FileWriter myWriter = new FileWriter(archivo);
[Link](escrito);
} [Link]();
[Link]("El vehiculo " + placa + " ha sido
ingresado");
b) VEHICULO } catch (IOException e) {
import [Link]; [Link]("An error occurred.");
import [Link]; [Link]();
import [Link]; // Import the File class } finally {
import [Link];
import [Link]; // Import the FileWriter class }
import [Link]; }
import [Link];
public void ingresarVehiculo(String placa, int tipo) {
public class Vehiculo {
[Link] = placa;
private LocalDateTime ingreso; [Link] = tipo;
private String placa;
private int tipoVehiculo; String archivo = placa + ".txt";
public static final int[] COSTO_MOTO = { 10000, 4650, 77
}; DateTimeFormatter formatter =
public static final int[] COSTO_CARRO = { 15000, 5500, [Link]("yyyy-MM-dd HH:mm");
120 };
String escrito = [Link](formatter);
public Vehiculo(String placa) {
try {
[Link] = [Link](); /* String currentPath = new
[Link] = placa; [Link](".").getCanonicalPath();
archivo = currentPath + "\\Vehiculos" + placa + ".txt";
} File file = new File(archivo);
if (![Link]()) {
public Vehiculo(String placa, int tipo) { [Link]();
}
4
FileWriter myWriter = new FileWriter(archivo); + costo);
[Link](escrito); }
[Link]();
[Link]("El vehiculo " + placa + " ha sido break;
ingresado");
} catch (IOException e) { case 2:
[Link]("An error occurred."); costo = ([Link]() *
[Link](); COSTO_MOTO[0] +
} finally { +[Link]() *
COSTO_MOTO[1] +
} +[Link]() *
} COSTO_MOTO[2]);
if (costo < 2000) {
/* En generarFactura se lee el archive de texto, se cambia el [Link]
formato de String por time y posteriormente se compara con el .println("El saldo a pagar por la
tiempo actual, generando la factura y el monto a pagar según estadia del carro " + [Link] + " es de: "
el tipo de vehículo, sea moto o carro. */ + 2000);
public void generarFactura(String placa, int tipo) { } else {
[Link]
String archivo = ""; .println("El saldo a pagar por la
try { estadia del carro " + [Link] + " es de: "
String currentPath = new + costo);
[Link](".").getCanonicalPath(); }
archivo = currentPath + "\\Vehiculos" + placa + ".txt"; break;
File myObj = new File(archivo);
try (Scanner myReader = new Scanner(myObj)) { }
while ([Link]()) {
String temporal = [Link](); }
[Link](temporal); [Link]();
DateTimeFormatter formatter =
[Link]("yyyy-MM-dd HH:mm"); }
LocalDateTime ingreso = String archivo2 = currentPath + "\\Vehiculos" +
[Link](temporal, formatter); [Link] + ".txt";
File myObj2 = new File(archivo2);
LocalDateTime ahora = [Link](); if ([Link]()) {
Duration duracion = [Link](ingreso, [Link]("La cuenta ha sido borrada
ahora); satisfactoriamente");
[Link]("La duracion es de: " +
duracion); } else {
[Link]([Link]() + " days, " [Link]("La cuenta no puede ser
+ [Link]() + " hours, " borrada");
+ [Link]() + " minutes"); }
switch (tipo) { } catch (IOException e) {
case 1: [Link]("No hay registro de esta placa en el
long costo = ([Link]() * parqueadero");
COSTO_CARRO[0] + [Link]();
+[Link]() * } finally {
COSTO_CARRO[1] +
+[Link]() * }
COSTO_CARRO[2]);
if (costo < 3000) { }
[Link]
.println("El saldo a pagar por la public void GenerarFactura() {
estadia del carro " + [Link] + " es de: "
+ 3000); String archivo = "";
} else { try {
[Link] String currentPath = new
.println("El saldo a pagar por la [Link](".").getCanonicalPath();
estadia del carro " + [Link] + " es de: "
5
archivo = currentPath + "\\Vehiculos" + [Link] + }
".txt";
File myObj = new File(archivo); break;
try (Scanner myReader = new Scanner(myObj)) {
while ([Link]()) { }
String temporal = [Link](); }
[Link](temporal); [Link]();
DateTimeFormatter formatter =
[Link]("yyyy-MM-dd HH:mm"); }
LocalDateTime ingreso = String archivo2 = currentPath + "\\Vehiculos" +
[Link](temporal, formatter); [Link] + ".txt";
File myObj2 = new File(archivo2);
LocalDateTime ahora = [Link](); if ([Link]()) {
Duration duracion = [Link](ingreso, [Link]("La cuenta ha sido borrada
ahora); satisfactoriamente");
[Link]("La duracion de la estadia de "
+ [Link] + " es de: " + duracion); } else {
[Link]([Link]() + " days, " [Link]("La cuenta no puede ser
+ [Link]() + " hours, " borrada");
+ [Link]() + " minutes"); }
switch ([Link]) { } catch (IOException e) {
case 1: [Link]("No hay registro de esta placa en el
long costo = ([Link]() * parqueadero");
COSTO_CARRO[0] + [Link]();
+[Link]() * } finally {
COSTO_CARRO[1] +
+[Link]() * }
COSTO_CARRO[2]);
if (costo < 3000) { }
[Link] Getters
.println("El saldo a pagar por la
estadia del carro " + [Link] + " es de: " public String getPlaca() {
+ 3000); return placa;
} else { }
[Link]
.println("El saldo a pagar por la public static int[] getCostoMoto() {
estadia del carro " + [Link] + " es de: " return COSTO_MOTO;
+ costo); }
}
public static int[] getCostoCarro() {
break; return COSTO_CARRO;
}
case 2:
costo = ([Link]() * }
COSTO_MOTO[0] +
+[Link]() *
COSTO_MOTO[1] +
+[Link]() * c) PERSONAS
COSTO_MOTO[2]); public class Personas extends Parqueadero {
if (costo < 2000) {
[Link] private String nombre;
.println("El saldo a pagar por la private int id;
estadia del carro " + [Link] + " es de: " private double celular;
+ 2000);
} else { //CONSTRUCTORES
[Link] public Personas() {
.println("El saldo a pagar por la }
estadia del carro " + [Link] + " es de: "
+ costo);
6
public Personas(String nombre, int capacidad, String
direccion, int nit, int costo) { public Cliente() {
super(nombre, capacidad, direccion, nit, costo);
} }
public Personas(String nombre, int capacidad, String public Cliente(String nombre, int capacidad, String
direccion, int nit, int costo, String nombre2, int id, direccion, int nit, int costo) {
double celular) { super(nombre, capacidad, direccion, nit, costo);
super(nombre, capacidad, direccion, nit, costo); }
nombre = nombre2;
[Link] = id; public Cliente(String nombre, int capacidad, String
[Link] = celular; direccion, int nit, int costo, String nombre2, int id,
} double celular) {
super(nombre, capacidad, direccion, nit, costo, nombre2,
public Personas(String nombre, int id, double celular) { id, celular);
}
[Link] = nombre;
[Link] = id; public Cliente(String nombre, int id, double celular, String
[Link] = celular; placa) {
super(nombre, id, celular);
} Vehiculo carro = new Vehiculo(placa);
[Link](carro);
// GETTERS & SETTERS [Link]();
}
public String getNombre() {
return nombre; //Metodo que muestra los vehiculos del propietario.
}
public void mostrarVehiculos() {
public void setNombre(String nombre) { for (int i = 0; i < [Link](); i++) {
[Link] = nombre; [Link]([Link](i).getPlaca());
} }
}
public int getId() {
return id; public Vehiculo mostrarVehiculos(int i) {
} return [Link](i);
}
public void setId(int id) {
[Link] = id; //Metodo que agrega vehiculos a la lista del propietario
} public void agregarVehiculo(String placa) {
Vehiculo carro = new Vehiculo(placa);
public double getCelular() { [Link](carro);
return celular; [Link]();
} }
public void setCelular(double celular) { public void agregarVehiculo(String placa, int tipo) {
[Link] = celular; Vehiculo carro = new Vehiculo(placa, tipo);
} [Link](carro);
[Link]();
} }
d) CLIENTE /*Metodo main que permite probar el programa desde el editor
import [Link]; de código */
import [Link]; public static void main(String[] args) {
//CONSTRUCTORES Cliente Juan = new Cliente("Juan", 1005755669,
public class Cliente extends Personas { 2741030, "RZY546");
[Link]();
List<Vehiculo> misVehiculos = new [Link]("IBP625", 1);
ArrayList<Vehiculo>(); [Link]();
7
[Link](0).GenerarFactura("RZY546", 2);
[Link](1).GenerarFactura();
