AP7-AA7.2-Ev1 - Programación Orientada A Objetos en Java

AP7-AA7.
2-EV1
EJERCICIOS DE PROGRAMACIÓN ORIENTADA A OBJETOS CON LENGUAJE
JAVA
BYRON ALEXANDER MONTENEGRO QUIÑONEZ

MARZO 2019
SERVICIO NACIONAL DE APRENDIZAJE (SENA)

CENTRO DE SERVICIOS FINANCIEROS (BOGOTÁ)
ANÁLISIS Y DESARROLLO DE SISTEMAS DE INFORMACIÓN (1565020)
AP7-AA7.2-Ev1-Ejercicios de Programación Orientada a Objetos con Lenguaje Java
ÍNDICE
1. INTRODUCCIÓN ........................................................................................................ 3
2. OBJETIVOS ................................................................................................................ 3
3. CONSIDERACIONES ................................................................................................. 3
4. PROCEDIMIENTO ...................................................................................................... 4
EJERCICIO 1 ............................................................................................................... 4
CLASE PRINCIPAL.JAVA ........................................................................................ 5
CLASE CITAS.JAVA ................................................................................................ 5
EJERCICIO 2 ............................................................................................................... 7
CLASE PRINCIPAL.JAVA ........................................................................................ 8
CLASE BUS.JAVA.................................................................................................... 9
EJERCICIO 3 ............................................................................................................. 11
CLASE PRINCIPAL.JAVA ...................................................................................... 12
CLASE CUENTA.JAVA .......................................................................................... 13
EJERCICIO 4 ............................................................................................................. 15
CLASE PRINCIPAL.JAVA ...................................................................................... 16
CLASE BANCO.JAVA ............................................................................................ 19
CLASE CLIENTE.JAVA .......................................................................................... 20
CLASE EMPRESA.JAVA ....................................................................................... 20
CLASE PERSONA.JAVA ....................................................................................... 21
5. EVIDENCIAS ............................................................................................................ 22
2
FAVA - Formación en Ambientes Virtuales de Aprendizaje SENA - Servicio Nacional de Aprendizaje
1. INTRODUCCIÓN
En el presente laboratorio desarrollará una serie de ejercicios de Programación
Orientada a Objetos (POO), empleando el lenguaje de programación JAVA, estos
ejercicios le ayudarán a aplicar los conceptos de la POO en contextos reales.
Con el desarrollo de aplicaciones orientadas a objetos el Analista y Desarrollador de

Sistemas de Información está preparado para sacar el máximo provecho a las
plataformas y lenguajes de programación más modernos y utilizados en la industria del
desarrollo de software actual.
2. OBJETIVOS
 Aplicar el concepto de Abstracción en el desarrollo de aplicaciones de Software
Orientado a Objetos.
 Aplicar el concepto de Encapsulación en el desarrollo de aplicaciones de Software
 Aplicar el concepto de Herencia en el desarrollo de aplicaciones de Software
 Seguir un diseño definido y aplicarlo en el código de programas orientados a
objetos.
 Comprender la diferencia entre los modificadores de acceso en Java.
 Definir métodos estáticos en el desarrollo de aplicaciones orientadas a objetos.
3. CONSIDERACIONES
Para el desarrollo del laboratorio es importante que tenga en cuenta los siguientes
aspectos relacionados en la tabla:
Ítem Descripción
Soporte Teórico Para el desarrollo del laboratorio se recomienda la lectura y
seguimiento de los Objetos de Aprendizaje:
 Programación Orientada a Objetos Aplicada.
Productos requeridos  Enunciados de los ejercicios a desarrollar disponibles
en este mismo documento.
 API de Java.
Herramientas SW El laboratorio puede ser desarrollado en cualquier IDE
(Ambiente de Desarrollo Integrado) para Java tal como:
 NetBeans
 JCreator
 BlueJ
 Eclipse
3
4. PROCEDIMIENTO
Para el desarrollo de cada uno de los ejercicios tenga en cuenta el siguiente
procedimiento:
1. Lea completamente el enunciado de cada ejercicio hasta comprender con claridad

lo que se está pidiendo.
2. Revise el diseño dado e identifique los conceptos de la Programación Orientada
a Objetos que debe aplicar.
3. Codifique cada ejercicio propuesto documentando las acciones incorporadas.
4. Compile la solución.
5. Realice las pruebas requeridas para asegurar su correcto funcionamiento.
6. Si esta correcto continúe con el punto 7, si no volver al paso 3.
7. Guarde cada ejercicio en una carpeta independiente con todos los archivos
requeridos para su ejecución.
EJERCICIO 1
1. Cree y compile la siguiente clase:
Cita
- int numero
- int tipo
- double tarifa
- double valorFinal
 Cita(int numero, int tipo, double tarifa)
 int getNumero()
 String getTipo()
 double getTarifa()
 double calcularValorFinal()
Notas:
 El método getTipo() debe retornar un String que puede ser “especialista” o
“general”, será general si la cita es tipo 1, 2 o 3 y será especialista si el tipo de cita
es 4 o 5.
 El valor final de la cita depende de la tarifa y el tipo de cita, las citas de tipo
“especialista” tienen un incremento del 50% sobre la tarifa y las citas de tipo
“general” tiene un descuento del 50% sobre la tarifa.
Cree la clase Principal.java donde solicite al usuario los datos para crear una cita (objeto
de la clase Cita) y a continuación presente los siguientes mensajes:
El número de la cita es: XXXXXX

Esta cita es de tipo: XXXXXXXX
4
Su tarifa normal es: XXXXXXXX

Pero por ser de tipo XXXXXXXX queda con un valor final de XXXXXXXX
CLASE PRINCIPAL.JAVA
package ejercicio1;
import javax.swing.JOptionPane;
/**
* Laboratorio 10. Programación Orientada a Objetos en Java
* Análisis y Desarrollo de Sistemas de Información (1565020)
* @author Byron Alexander Montenegro Quiñonez
* Ejercicio N° 1
*/
public class Principal {
public static void main(String[] args) {
int numero =
Integer.parseInt(JOptionPane.showInputDialog(null, "Ingrese el número
de la cita:"));
int tipo = Integer.parseInt(JOptionPane.showInputDialog(null,
"Introduzca el tipo de cita: \n(General: 1,2 o 3 \nEspecialista: 4 o
5)"));
double tarifa =
Double.parseDouble(JOptionPane.showInputDialog(null, "Introduzca la
tarifa de la cita:"));
Citas cita = new Citas(numero, tipo, tarifa);
System.out.println("El número de la cita es:

"+cita.getNumero());
System.out.println("Esta cita es de tipo: "+cita.getTipo());
System.out.println("Su tarifa normal es: "+cita.getTarifa());
System.out.println("Pero por ser de tipo "+cita.getTipo()+"
queda con un valor final de "+cita.calcularValorFinal());
}
}
CLASE CITAS.JAVA
5
package ejercicio1;
/**
* Ejercicio N° 1
*/
public class Citas {
private int numero;

private int tipo;
private double tarifa;
private double valorFinal;
public Citas(int numero, int tipo, double tarifa) {

this.numero = numero;
this.tipo = tipo;
this.tarifa = tarifa;
}
public int getNumero() {

return numero;
}
public String getTipo() {

if (tipo <= 3) {
return "General";
} else {
return "Especialista";
}
}
public double getTarifa() {

return tarifa;
}
public double calcularValorFinal() {

double porcentaje = tarifa * 0.5;
if (tipo <= 3) {
valorFinal = tarifa - porcentaje;
} else {
6
valorFinal = tarifa + porcentaje;

}
return valorFinal;
}
EJERCICIO 2
Bus
- String placa
- int capacidadPasajeros
- double precioPasaje
- int pasajerosActuales
- int totalPasajeros
 Bus(String placa, int capacidad, double pasaje)
 String getPlaca()
 int getCapacidad()
 double getPrecioPasaje()
 int getPasajerosTotales()
 int getPasajerosActuales()
 void subirPasajeros(int pasajeros)
 void bajarPasajeros(int pasajeros)
 double getDineroAcumulado()
Notas:
 getPlaca: Obtiene la placa del bus.

 getCapacidad: Obtiene la capacidad de pasajeros del bus.
 getPrecioPasaje: Obtiene el valor del pasaje.
 getPasajerosActuales: Obtiene el número de pasajeros que se encuentra en el
bus.
 getPasajerosTotales: Obtiene el número de pasajeros que se han subido al bus
 subirPasajeros: sube una cantidad de pasajeros al bus, teniendo en cuenta que
no sobrepase la capacidad del bus.
 bajarPasajeros: baja una cantidad de pasajeros del bus, teniendo en cuenta que
no baje más pasajeros de los que realmente existen en el bus.
 getDineroAcumulado: Obtiene todo el dinero que ha acumulado el bus teniendo
en cuenta todos los pasajeros que se han subido y el valor del pasaje.
7
Cree y compile la clase Principal.java donde instancie un objeto de la clase Bus y pruebe
cada uno de sus métodos.
package Bus;
/**
* Ejercicio N° 2
*/
String placa = JOptionPane.showInputDialog(null, "Digite la

placa del bus:");
int capacidad =
Integer.parseInt(JOptionPane.showInputDialog(null, "Digite la
capacidad de pasajeros del bus:"));
double pasaje =
Double.parseDouble(JOptionPane.showInputDialog(null, "Digite el
precio del pasaje por persona:"));
int pasajerosActuales =
Integer.parseInt(JOptionPane.showInputDialog(null, "Digite los
pasajeros actuales que se encuentran en el bus:"));
if (pasajerosActuales > capacidad) {

JOptionPane.showConfirmDialog(null, "Los pasajeros
superan la capacidad del cupo del bus");
} else {
Bus bus = new Bus(placa, capacidad, pasaje,
pasajerosActuales);
int pasajerosSub =
pasajeros a subir al bus:"));
bus.subirPasajeros(pasajerosSub);
8
int pasajerosBaj =
pasajeros a subir al bus:"));
bus.bajarPasajeros(pasajerosBaj);
System.out.println("La placa del bus es:

"+bus.getPlaca());
System.out.println("La capacidad del bus es de:
"+bus.getCapacidadPasajeros()+" pasajeros");
System.out.println("El precio del pasaje es de:
$"+bus.getPrecioPasaje());
System.out.println("Los pasajeros actuales que se
encuentran en el bus es: "+bus.getPasajerosActuales());
System.out.println("Los pasajeros que se subieron al bus
fueron: "+pasajerosSub);
System.out.println("Los pasajeros que se subieron al bus
fueron: "+pasajerosBaj);
System.out.println("El total de pasajeros que se subieron
al bus son: "+bus.getPasajerosTotales());
System.out.println("El dinero acumulado del transporte de
los pasajeros es de: "+bus.dineroAcumulado());
}
}
}
CLASE BUS.JAVA
package Bus;
/**
* Ejercicio N° 2
*/
public class Bus {
private String placa;

private int capacidadPasajeros;
9
private double precioPasaje;

private int pasajerosActuales;
private int totalPasajeros;
private double dineroAcumulado;
private int pasajerosSubidos;
private int pasajerosBajados;
public Bus(String placa, int capacidadPasajeros, double

precioPasaje, int pasajerosActuales) {
this.placa = placa;
this.capacidadPasajeros = capacidadPasajeros;
this.precioPasaje = precioPasaje;
this.pasajerosActuales = pasajerosActuales;
}
public String getPlaca() {

return placa;
}
public int getCapacidadPasajeros() {

return capacidadPasajeros;
}
public double getPrecioPasaje() {

return precioPasaje;
}
public int getPasajerosActuales() {

if (pasajerosActuales > capacidadPasajeros) {
JOptionPane.showConfirmDialog(null, "Los pasajeros
actuales sobrepasan la capacidad del bus");
}
return pasajerosActuales;
}
public void subirPasajeros(int pasajerosSub) {

if (pasajerosActuales < capacidadPasajeros) {
pasajerosSubidos = pasajerosSub;
} else {
JOptionPane.showConfirmDialog(null, "La cantidad de
pasajeros a subir en el bus sobrepasa el límite del cupo");
}
}
10
public int getPasajerosTotales() {

if (pasajerosActuales > capacidadPasajeros) {
System.out.println("No se puede subir
"+pasajerosSubidos+" pasajeros por sobrecupo");
totalPasajeros = pasajerosActuales;
} else if(pasajerosActuales + pasajerosSubidos >

capacidadPasajeros) {
System.out.println("No se puede subir
"+pasajerosSubidos+" pasajeros por sobrecupo");
totalPasajeros = pasajerosActuales;
} else {
totalPasajeros = pasajerosActuales + pasajerosSubidos;
return totalPasajeros;
}
public void bajarPasajeros(int pasajerosBaj) {

if (pasajerosBaj > pasajerosActuales) {
JOptionPane.showConfirmDialog(null, "La cantidad de
pasajeros a bajar es mayor a los pasajeros actuales");
} else {
pasajerosBajados = pasajerosActuales - pasajerosBaj;
}
}
public double dineroAcumulado() {

dineroAcumulado = totalPasajeros * precioPasaje;
return dineroAcumulado;
}
}
EJERCICIO 3
Cuenta
11
- String numero
- String tipo
- double saldoActual
- double saldoMinimo
 Cuenta(int numero, String tipo, double valorInicial)
 void consignar (double monto)
 void retirar (double monto)
 double getSaldo()
 double getSaldoMinimo()
 double getCapacidadCredito()
Notas:
• Las cuentas solo pueden ser de tipo “ahorro” o “crédito”

• El saldo mínimo de una cuenta es el 10% del valor inicial con que se crea la
cuenta.
• Consignar (double monto): incrementa el dinero de la cuenta con base en el monto
de dinero que se desea consignar.
• Retirar (double monto): retira el monto dado de la cuenta siempre y cuando la
cuenta no quede con un saldo inferior al saldo mínimo, si esto ocurre, solo se
retirará el dinero autorizado.
• getSaldo(): obtiene el saldo actual de la cuenta.
• getSaldoMinimo(): obtiene el saldo mínimo de la cuenta.
• getCapacidadCredito(): Para cuentas de ahorro, la capacidad de crédito es igual
a la diferencia entre al saldo actual y el saldo mínimo y para cuentas de crédito, la
capacidad de crédito es 3 veces el saldo actual.
Cree y compile la clase Principal.java y en ella cree un objeto de la clase Cuenta y pruebe
cada uno de sus métodos.
package Cuenta;
/**
* Ejercicio N° 3
*/
12
int numero =
Integer.parseInt(JOptionPane.showInputDialog(null, "Digite el número
de la cuenta:"));
String tipo = JOptionPane.showInputDialog(null, "Digite \n1
para Cuenta de Ahorro \n2 para Cuenta de Crédito:");
double valorInicial =
Double.parseDouble(JOptionPane.showInputDialog(null, "Digite el valor
a consignar en la cuenta:"));
Cuenta cuenta = new Cuenta(numero, tipo, valorInicial);
double montoCon =
Double.parseDouble(JOptionPane.showInputDialog(null, "Digite el monto
a ingresar a la cuenta:"));
cuenta.consignar(montoCon);
double montoRet =
Double.parseDouble(JOptionPane.showInputDialog(null, "Digite el monto
a retirar de la cuenta:"));
cuenta.retirar(montoRet);
System.out.println("Su saldo actual es de:

"+cuenta.getSaldo());
System.out.println("El saldo mínimo de su cuenta es de:
"+cuenta.getSaldoMinimo());
System.out.println("La capacidad de crédito es de:
"+cuenta.getCapacidadCredito());
}
}
CLASE CUENTA.JAVA
package Cuenta;
/**
13

* Ejercicio N° 3
*/
public class Cuenta {
private int numero;

private String tipo;
private double saldoActual;
private double saldoMinimo;
private double valorInicial;
private double capacidadCredito;
public Cuenta(int numero, String tipo, double valorInicial) {

this.numero = numero;
this.tipo = tipo;
this.saldoActual = valorInicial;
}
public void consignar(double montoConsignar) {

saldoActual = saldoActual + montoConsignar;
}
public void retirar(double montoRetirar){

saldoActual = saldoActual - montoRetirar;
double dineroAutorizado;
if (saldoActual < saldoMinimo) {
saldoActual = saldoActual + montoRetirar;
dineroAutorizado = saldoActual - saldoMinimo;
JOptionPane.showConfirmDialog(null, "Saldo insuficiente,

máximo a retirar: "+dineroAutorizado);
saldoActual = saldoActual - dineroAutorizado;
}
}
public double getSaldo() {

return saldoActual;
}
public double getSaldoMinimo() {

saldoMinimo = saldoActual * 0.1;
return saldoMinimo;
}
14
public double getCapacidadCredito() {

if ("1".equals(tipo)) {
capacidadCredito = saldoActual - saldoMinimo;
}
if ("2".equals(tipo)) {
capacidadCredito = saldoActual * 3;
}
return capacidadCredito;
}
}
EJERCICIO 4
4. A partir del siguiente diseño, cree las clases correspondientes y su respectivo código
para generar los listados que se solicitan a continuación:
15
a) Todos los nombres de los clientes que tiene el banco

b) Todas los nombres y cédulas de las personas clientes del banco
c) El nombre y representante de cada Empresa
d) Nombres de los clientes menores de edad
e) El nombre y la edad del cliente más Joven
f) El nombre y la edad del cliente más viejo
package Banco;
import java.util.ArrayList;
import java.util.List;
/**
* Ejercicio N° 4
*/
private static Cliente per;
List<Cliente> lista = new ArrayList<>();

int numeroDeClientes =
Integer.parseInt(JOptionPane.showInputDialog(null, "Numero de
Clientes:"));
for (int i = 1; i < numeroDeClientes; i++) {

int tipoCliente =
Integer.parseInt(JOptionPane.showInputDialog(null, "Tipo de Cliente:
\n1 para Empresas \n2 para Persona:"));
String nom = JOptionPane.showInputDialog(null, "Nombre
del cliente:");
if (tipoCliente == 1) {
String nit = JOptionPane.showInputDialog(null, "NIT
16
de la empresa:");
String r = JOptionPane.showInputDialog(null, "Nombre
del representante legal:");
Empresa empresa = new Empresa(nit, nom, r);
empresa.obtenerIdentificacion();
lista.add(empresa);
} else {
String ced = JOptionPane.showInputDialog(null, "N°

cédula del cliente:");
int ed =
Integer.parseInt(JOptionPane.showInputDialog(null, "Edad del
cliente:"));
Persona per = new Persona(ced, nom, ed);
lista.add(per);
}
}
System.out.println("Nombres que tiene el banco: ");

for (int cuenta = 0; cuenta < lista.size(); cuenta++) {
System.out.println(lista.get(cuenta).nombre);
}
System.out.println("Nombres y cédulas de los clientes:

");
if (lista.get(cuenta) instanceof Persona) {
System.out.println("La cédula del cliente es:
"+lista.get(cuenta).obtenerIdentificacion());
System.out.println("El nombre del cliente es:
"+lista.get(cuenta).obtenerNombre());
}
}
System.out.println("Nombres y representantes de cada

empresa:");
if (lista.get(cuenta) instanceof Empresa) {
System.out.println("Nombre del cliente:
System.out.println("Nombre del representante:
"+lista.get(cuenta).obtenerRepresentante());
17
}
}
System.out.println("Nombres de los clientes menores de

edad:");
if (lista.get(cuenta).obtenerEdad() < 18) {
System.out.println("Nombre del cliente es:
}
}
}
int menor = 1000;

if (lista.get(cuenta).obtenerEdad() > 1) {
if (lista.get(cuenta).obtenerEdad() < menor)
{
menor = lista.get(cuenta).obtenerEdad();
}
}
}
}
System.out.println("Edad del cliente más joven es:

"+menor);
int mayor = 0;
if (lista.get(cuenta).obtenerEdad() > 18) {
if (lista.get(cuenta).obtenerEdad() > mayor)
{
mayor = lista.get(cuenta).obtenerEdad();
}
}
}
}
System.out.println("Edad del cliente más viejo es:

"+mayor);
}
18
CLASE BANCO.JAVA
package Banco;
/**
* Ejercicio N° 4
*/
public class Banco {
String nombre;
Cliente clientes[];
int numeroDeClientes;
public Banco(String nomb) {

this.nombre = nomb;
}
public String obtenerNombre() {

return nombre;
}
public void cambiarNombre(String nombre) {
}
public void adCliente(Cliente clie) {
public int obtenerNumeroClientes() {

return numeroDeClientes;
}
Cliente obtenerCliente(int posicion) {

return null;
}
19
Cliente[] obtenerClientes() {
return null;
}
}
CLASE CLIENTE.JAVA
package Banco;
/**
* Ejercicio N° 4
*/
abstract class Cliente {
protected String nombre;
public Cliente(String nom) {

this.nombre = nom;
}
public String obtenerNombre() {

return nombre;
}
abstract String obtenerIdentificacion();

abstract String obtenerRepresentante();
abstract int obtenerEdad();
}
CLASE EMPRESA.JAVA
package Banco;
/**
20

* Ejercicio N° 4
*/
public class Empresa extends Cliente {
String nit;
String representante;
public Empresa(String n, String nom, String r) {

super(nom);
this.nit = n;
this.representante = r;
}
public String obtenerIdentificacion() {

return nit;
}
public String obtenerRepresentante() {

return representante;
}
public String cambiarRepresentante(String repres) {

return null;
}
public int obtenerEdad() {

return 1000;
}
}
CLASE PERSONA.JAVA
package Banco;
/**
* Ejercicio N° 4
*/
21
public class Persona extends Cliente {

String cedula;
int edad;
public Persona(String ced, String nom, int ed) {

super(nom);
this.cedula = ced;
this.edad = ed;
}
public String obtenerIdentificacion() {

return cedula;
}
public int obtenerEdad() {

return edad;
}
public void cumplirAnos() {
public String obtenerRepresentante() {

return null;
}
}
5. EVIDENCIAS
Carpeta comprimida con el nombre laboratorio10 y en su interior subcarpetas (una
subcarpeta por cada ejercicio) con los respectivos archivos .java para su ejecución.
22

AP7-AA7.2-Ev1 - Programación Orientada A Objetos en Java

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

AP7-AA7.2-Ev1 - Programación Orientada A Objetos en Java

Uploaded by

Copyright:

Available Formats

AP7-AA7.

BYRON ALEXANDER MONTENEGRO QUIÑONEZ

SERVICIO NACIONAL DE APRENDIZAJE (SENA)

Con el desarrollo de aplicaciones orientadas a objetos el Analista y Desarrollador de

1. Lea completamente el enunciado de cada ejercicio hasta comprender con claridad

El número de la cita es: XXXXXX

Su tarifa normal es: XXXXXXXX

public class Principal {

public static void main(String[] args) {

Citas cita = new Citas(numero, tipo, tarifa);

System.out.println("El número de la cita es:

public class Citas {

private int numero;

public Citas(int numero, int tipo, double tarifa) {

public int getNumero() {

public String getTipo() {

public double getTarifa() {

public double calcularValorFinal() {

valorFinal = tarifa + porcentaje;

 getPlaca: Obtiene la placa del bus.

public class Principal {

public static void main(String[] args) {

String placa = JOptionPane.showInputDialog(null, "Digite la

if (pasajerosActuales > capacidad) {

System.out.println("La placa del bus es:

public class Bus {

private String placa;

private double precioPasaje;

public Bus(String placa, int capacidadPasajeros, double

public String getPlaca() {

public int getCapacidadPasajeros() {

public double getPrecioPasaje() {

public int getPasajerosActuales() {

public void subirPasajeros(int pasajerosSub) {

public int getPasajerosTotales() {

} else if(pasajerosActuales + pasajerosSubidos >

public void bajarPasajeros(int pasajerosBaj) {

public double dineroAcumulado() {

• Las cuentas solo pueden ser de tipo “ahorro” o “crédito”

public class Principal {

public static void main(String[] args) {

Cuenta cuenta = new Cuenta(numero, tipo, valorInicial);

System.out.println("Su saldo actual es de:

* Análisis y Desarrollo de Sistemas de Información (1565020)

private int numero;

public Cuenta(int numero, String tipo, double valorInicial) {

public void consignar(double montoConsignar) {

public void retirar(double montoRetirar){

JOptionPane.showConfirmDialog(null, "Saldo insuficiente,

public double getSaldo() {

public double getSaldoMinimo() {

public double getCapacidadCredito() {

a) Todos los nombres de los clientes que tiene el banco

public class Principal {

private static Cliente per;

public static void main(String[] args) {

List<Cliente> lista = new ArrayList<>();

for (int i = 1; i < numeroDeClientes; i++) {

String nit = JOptionPane.showInputDialog(null, "NIT

String ced = JOptionPane.showInputDialog(null, "N°

System.out.println("Nombres que tiene el banco: ");

System.out.println("Nombres y cédulas de los clientes:

System.out.println("Nombres y representantes de cada