Servicio Nacional de Aprendizaje - SENA

Análisis y Desarrollo de Sistema de Información – ADSI

AP7-AA7.2-Ev1-Ejercicios de programación orientada a objetos con

lenguaje Java

Presentado por:

Claudia Benavides

Mayo 2019
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);

}
}