Programacin 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 mtodo 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 continuacin presente los siguientes mensajes: El
nmero 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 nmero de pasajeros que se encuentra en el bus
getPasajerosTotales: Obtiene el nmero 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 ms 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 mtodos.

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 crdito El saldo mnimo
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 mnimo, si esto
ocurre, solo se retirar el dinero autorizado. getSaldo(): obtiene el saldo
actual de la cuenta. getSaldoMinimo(): obtiene el saldo mnimo de la cuenta.
getCapacidadCredito(): Para cuentas de ahorro, la capacidad de crdito es igual a
la diferencia entre al saldo actual y el saldo mnimo y para cuentas de crdito, la
capacidad de crdito 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
mtodos.

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;

}

/* -----------------------------------/
/ Mtodo para consignar en la cuenta /
/------------------------------------*/

public void consignar (double monto){

saldoActual=saldoActual+monto;

}

/* -----------------------------------/
/ Mtodo para saber saldo mnimo /
/------------------------------------*/

double getSaldoMinimo(){

saldoMinimo=valorInicial*0.1;

return saldoMinimo;

 }

/* -----------------------------------/
/ Mtodo 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 sera inferior a su saldo mnimo\n"
+ ", por lo tanto solo puede retirar: " + autorizado);
saldoActual=saldoActual-autorizado;

}


}

/* ----------------------------------/
/ Mtodo para consultar saldo /
/-----------------------------------*/

double getSaldo(){

return saldoActual;

}

/* -------------------------------------------/
/ Mtodo para conocer la capacidad de crdito/
/-------------------------------------------*/

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 diseo, cree las clases correspondientes y su respectivo

cdigo para generar los listados que se solicitan a continuacin:
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 cumplirAos( )

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

}
}