AP7-AA7.

2-EV1-EJERCICIOS DE PROGRAMACIÓN ORIENTADA A OBJETOS CON LENGUAJE

JAVA

Aprendiz:
Jhon Alexander Gelves Arias
Diego Fernando López Banguero
Sandra Yaneth Sanabria Estupiñán
Walter Yesid Tolosa Escalante

Instructores:
JORGE MARIO GIRALDO DUQUE
JONATHAN QUICENO VARGAS

SENA
Centro de Turismo y Comercio Regional Quindío
2018
Programación orientada a objetos en JAVA

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 Su tarifa normal es:
XXXXXXXX Pero por ser de tipo XXXXXXXX queda con un valor final de
XXXXXXXX

package EjerciciosJava;

public class Cita {

int numero;
int tipo;
double tarifa;
double valorFinal=0;

public Cita(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 percent=tarifa*0.5;
if(tipo<=3){

valorFinal=tarifa-percent;
}

else{

valorFinal=tarifa+percent;
}

return valorFinal;
}
}

package EjerciciosJava;

import javax.swing.JOptionPane;

public class Principal1 {

public static void main(String[] args) {

int numero =Integer.parseInt(JOptionPane.showInputDialog(null,"Introduzca el numero de la

cita"));
int tipo = Integer.parseInt(JOptionPane.showInputDialog(null, "Introduzca el tipo de cita (Para
general: 1, 2 y 3 y para especialista: 4 y 5)"));
double tarifa = Double.parseDouble(JOptionPane.showInputDialog(null, "Introduzca la tarifa"));

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

System.out.println("El numero de la cita es: "+cita.getNumero());

System.out.println("El tipo de cita es: "+ 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());

}
2. Cree y compile la siguiente clase:
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. Cree y compile la clase Principal.java donde instancie un objeto de la
clase Bus y pruebe cada uno de sus métodos.

package EjerciciosJava;

import javax.swing.JOptionPane;

public class Bus {

String placa;
int capacidadPasajeros;
double precioPasaje;
int pasajerosActuales;
int totalPasajeros;
double dineroAcumulado;
public int pasajeroSsubidos;
int pasajeros1;
int totalAcumulado;

public Bus (String placa, int capacidad, double pasaje, int actuales){

this.placa=placa;
this.capacidadPasajeros=capacidad;
this.precioPasaje=pasaje;
this.pasajerosActuales=actuales;

public String getPlaca(){

return placa;

}
public int getCapacidad(){

return capacidadPasajeros;

}
public double getPrecioPasaje(){

return precioPasaje;

}
public int getPasajerosTotales(){

return totalPasajeros;

}
public int getPasajerosActuales(){

return pasajerosActuales;

}
public void subirPasajeros(int pasajeros){

if (pasajeros > capacidadPasajeros) {

JOptionPane.showMessageDialog(null, " No se pueden subir " + pasajeros + ", porque es

SOBRECUPO ");

}
else {
if ((pasajerosActuales + pasajeros) > capacidadPasajeros) {
JOptionPane.showMessageDialog(null, " No se pueden subir " + pasajeros + ", porque es
SOBRECUPO ");

}else{

totalPasajeros=pasajeros;
pasajerosActuales=pasajerosActuales+pasajeros;
totalAcumulado = pasajerosActuales + pasajeros;

}
}

public void getDineroAcumulado(){

dineroAcumulado=(pasajerosActuales*precioPasaje);

public double totalDineroAcumulado(){

return dineroAcumulado;
}
public void bajarPasajeros(int pasajeros1){

if (pasajeros1>pasajerosActuales) {

JOptionPane.showMessageDialog(null, "La cantidad de pasajeros que desea bajar es mayor

al numero de pasajeros que actualmente hay en el bus!!!");

}
else{
pasajerosActuales=pasajerosActuales-pasajeros1;
}

}
}

package EjerciciosJava;

import javax.swing.JOptionPane;

public class Principal2 {

public static void main(String[] args) {

String placa=JOptionPane.showInputDialog("Digite placa del bus");

int capacidad=Integer.parseInt(JOptionPane.showInputDialog(null,"Ingrese capacidad del
bus"));
int actuales = Integer.parseInt(JOptionPane.showInputDialog(null, "Ingrese numero de
pasajeros que estan en el bus "));
double pasaje = Double.parseDouble(JOptionPane.showInputDialog(null,"Valor pasaje"));

if (actuales>capacidad) {

System.out.println("Error!!! El numero actual de pasajeros sobrepasa la capacidad del bus");

}else{
Bus bus = new Bus(placa,capacidad,pasaje,actuales);

int pasajeros=Integer.parseInt(JOptionPane.showInputDialog(null,"Ingrese cantidad de

pasajeros a subir al bus!"));
bus.subirPasajeros(pasajeros);
JOptionPane.showMessageDialog(null,"El numero de pasajeros actuales es:
"+bus.getPasajerosActuales());
JOptionPane.showMessageDialog(null,"El bus tiene una capacidad de:
"+bus.getCapacidad());
JOptionPane.showMessageDialog(null,"La placa del bus es: "+bus.getPlaca());
bus.getDineroAcumulado();
JOptionPane.showMessageDialog(null,"El numero de pasajeros que se han subido es:
"+bus.getPasajerosTotales());

int pasajeros1= Integer.parseInt(JOptionPane.showInputDialog(null, "Ingrese numero de

pasajeros que va a bajar del bus"));

bus.bajarPasajeros(pasajeros1);
 JOptionPane.showMessageDialog(null,"El dinero acumulado es: $" +
bus.totalDineroAcumulado());
}

}
}

3. Cree y compile la siguiente clase:

Cuenta
- 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 EjerciciosJava;

import javax.swing.JOptionPane;

public class Cuenta {

/* ---------------------------/
/ Atributos de la clase cuenta/
/----------------------------*/

int numero;
String tipo;
double valorInicial;
double saldoActual;
double saldoMinimo;
double capacidad;
double autorizado;
double capacidadCredito;

/* ---------------------------/
 / Metodos de la clase Cuenta /
/----------------------------*/

// Metodo Constructor
Cuenta(int numero,String tipo,double valorInicial){

this.numero=numero;
this.tipo=tipo;
this.saldoActual=valorInicial;
this.valorInicial=valorInicial;

/* -----------------------------------/
/ Método para consignar en la cuenta /
/------------------------------------*/

public void consignar (double monto){

saldoActual=saldoActual+monto;

/* -----------------------------------/
/ Método para saber saldo mÃÂnimo /
/------------------------------------*/

double getSaldoMinimo(){

saldoMinimo=valorInicial*0.1;

return saldoMinimo;

/* -----------------------------------/
/ Método para retirar dinero de la cuenta /
/------------------------------------*/

public void retirar (double monto1){

saldoActual=saldoActual-monto1;

if (saldoActual<saldoMinimo) {
saldoActual=saldoActual+monto1;
autorizado=saldoActual-saldoMinimo;
JOptionPane.showMessageDialog(null, "No puede retirar ésta cantidad de dinero
porque su saldo actual serÃÂa inferior a su saldo mÃÂnimo\n"
+ ", por lo tanto solo puede retirar: " + autorizado);
saldoActual=saldoActual-autorizado;

}
 /* ----------------------------------/
/ Método para consultar saldo /
/-----------------------------------*/

double getSaldo(){

return saldoActual;

/* -------------------------------------------/
/ Método para conocer la capacidad de crédito/
/-------------------------------------------*/

double getCapacidadCredito(){

if ("ahorro".equals(tipo)) {

capacidadCredito=saldoActual-saldoMinimo;

if ("credito".equals(tipo)) {

capacidadCredito=saldoActual*3;

return capacidadCredito;

}
}

package EjerciciosJava;

import javax.swing.JOptionPane;

public class Principal3 {

public static void main(String[] args) {

/* --------------------------/
/ Captura de datos inicales /
/---------------------------*/
int numero=Integer.parseInt(JOptionPane.showInputDialog("Digite el numero de la cuenta"));
String tipo=JOptionPane.showInputDialog("Digite el tipo de cuenta, ahorro o credito");
double valorInicial=Double.parseDouble(JOptionPane.showInputDialog("Digite el valor que va
a consignar inicialmente"));

/* --------------------------/
/ Creando el objeto Cuenta /
/---------------------------*/

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

 double monto=Double.parseDouble(JOptionPane.showInputDialog("Digite la cantidad de
dinero a consignar"));
cuenta.consignar(monto);

cuenta.getSaldoMinimo();

double monto1=Double.parseDouble(JOptionPane.showInputDialog("Digite la cantidad de

dinero a retirar"));

cuenta.retirar(monto1);

JOptionPane.showMessageDialog(null,"Su saldo Actual es: " + cuenta.getSaldo());

JOptionPane.showMessageDialog(null,"El saldo minimo de su cuenta es: " +
cuenta.getSaldoMinimo());
JOptionPane.showMessageDialog(null,"Su capacidad de Credito es: " +
cuenta.getCapacidadCredito());

}
}

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:
Banco
-String nombre -Cliente clientes[ ] -int numeroDeClientes
+ Banco(String nom) + String obtNombre() + void cambiarNombre(String nombre) + void
adCliente(Cliente clie) + int obtNumClientes( ) + Cliente obtCliente(int posicion) + Cliente [ ]
obtClientes( )

Cliente {abstract}
-String nombre
+ Cliente (String nombre) + String obtNombre( ) + abstract String obtIdentificacion( )

Empresa
-String nit -String representante
+Empresa(String nit,String nom,String r) + String obtIdentificacion( ) + String obtRepresentante( ) +
String cambiarRepres(String repres)

Persona
-String cedula -int edad
+ Persona(String ced,String nom,int ed) + String obtIdentificacion( ) + String obtEdad( ) + void
cumplirAños( )

package Ejercicios;
import javax.swing.JOptionPane;
class Banco{
String nombre;
Cliente clientes[];
int numeroDeClientes;

public Banco(String nomb){

this.nombre=nomb;

}
public String obtnombre(){
 return nombre;
}
public void cambiarNombre(String nombre){

}
public void adCliente(Cliente clie){

}
public int obtNumClientes(){
return numeroDeClientes;
}
Cliente obtCliente(int posicion){
return null;

}
Cliente[] obtClientes(){
return null;

package Ejercicios;

abstract class Cliente{

protected String nombre;

public Cliente(String nom)

{
this.nombre=nom;

public String obtNombre() {

return nombre;
}

abstract String obtIdentificacion();

abstract String obtRepresentante();

abstract int obtEdad();

}

package Ejercicios;

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 obtIdentificacion(){

return nit;

}
public String obtRepresentante(){
return representante;

}
public String cambiarRepres(String repres){
return null;

}
public int obtEdad(){
return 1000;

package Ejercicios;

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 obtIdentificacion(){

return cedula;
}
public int obtEdad(){
return edad;
}
public void cumpliranos(){

}
 public String obtRepresentante(){
return null;

package Ejercicios;
import javax.swing.JOptionPane;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class Principal4 {

private static Cliente per;

public static void main(String args[]) {

List<Cliente> lista = new ArrayList<>();
int numeroDeClientes = Integer.parseInt(JOptionPane.showInputDialog(null, "Ingrese el
numero de clientes"));
for (int i = 1; i <= numeroDeClientes; i++) {
int tipoCliente = Integer.parseInt(JOptionPane.showInputDialog(null, "Ingrese el tipo de
cliente: 1 para Empresa o 2 para Persona"));
String nom = JOptionPane.showInputDialog(null, "Ingrese el nombre del cliente");
if (tipoCliente == 1) {
String nit = JOptionPane.showInputDialog(null, "Ingrese el nit de la empresa");
String r = JOptionPane.showInputDialog(null, "Ingrese el representante");
Empresa emp = new Empresa(nit, nom, r);
emp.obtIdentificacion();
//Esta linea no se con que fin es
//emp.obtRepresentante();
//ESTA LINEA ES LA QUE UD BORRO, AQUI ES DONDE SE ASIGNA EL OBJETO AL
ARRAY LIST
lista.add(emp);
} else {
String ced = JOptionPane.showInputDialog(null, "Ingrese la cedula de la persona");
int ed = Integer.parseInt(JOptionPane.showInputDialog(null, "Ingrese la edad de la
persona"));
Persona per = new Persona(ced, nom, ed);
//AQUI ES DONDE SE ASIGNA EL OBJETO AL ARRAY LIST
lista.add(per);
}
}
System.out.println("Todos los nombres que tiene el banco son: ");
for(int cuenta = 0; cuenta < lista.size(); cuenta++){
System.out.println(lista.get(cuenta).nombre);
}
System.out.println("Todos los nombres y cedulas de las personas clientes del banco son: ");
for(int cuenta = 0; cuenta < lista.size(); cuenta++){
if (lista.get(cuenta) instanceof Persona){
System.out.println("La cedula del cliente es "+lista.get(cuenta).obtIdentificacion());
System.out.println("El nombre del cliente es "+lista.get(cuenta).obtNombre());
}
 }
System.out.println("Todos los nombres y representantes de cada empresa son: ");
for(int cuenta = 0; cuenta < lista.size(); cuenta++){
if (lista.get(cuenta) instanceof Empresa){
System.out.println("El nombre del cliente es "+lista.get(cuenta).obtNombre());
System.out.println("El nombre del representante es
"+lista.get(cuenta).obtRepresentante());
}
}
System.out.println("Los nombres de los clientes menores de edad son: ");
for(int cuenta = 0; cuenta < lista.size(); cuenta++){
if (lista.get(cuenta) instanceof Persona){
if (lista.get(cuenta).obtEdad()<18){
System.out.println("El nombre del cliente es "+lista.get(cuenta).obtNombre());
}
}
}
int menor=1000;
for(int cuenta = 0; cuenta < lista.size(); cuenta++){
if (lista.get(cuenta) instanceof Persona){
if (lista.get(cuenta).obtEdad()>1){
if (lista.get(cuenta).obtEdad()<menor){
menor=lista.get(cuenta).obtEdad();
}
}
}
}
System.out.println("La edad del cliente mas joven es "+menor );
int mayor=0;
for(int cuenta = 0; cuenta < lista.size(); cuenta++){
if (lista.get(cuenta) instanceof Persona){
if (lista.get(cuenta).obtEdad()>18){
if (lista.get(cuenta).obtEdad()>mayor){
mayor=lista.get(cuenta).obtEdad();
}
}
}
}
System.out.println("La edad del cliente mas viejo es "+mayor);

}
}