Reto 5

// Librerias de java para utilizar
import java.util.ArrayList;
public class CDT

{
// -----------------------------------------------------------------
// Atributos
// -----------------------------------------------------------------
/**
* Valor inicial del CDT.
*/
private double valorInvertido;
/**
* Interés mensual que del CDT
*/
private double interesMensual;
/**
* Mes de apertura del CDT.
*/
private int mesApertura;
// -----------------------------------------------------------------
// Métodos
// -----------------------------------------------------------------
/**
* Inicializa el CDT. 
* post: El valor invertido, el interés mensual y la fecha se
inicializaron en 0.
*/
public CDT( )
{
valorInvertido = 0;
interesMensual = 0;
mesApertura = 0;
}
/**
* Retorna el interés que paga el banco mensualmente por este CDT.
* @return Interés mensual del CDT.
*/
public double darInteresMensual( )
{
return interesMensual;
}
public double darValorInvertido( )

{
return valorInvertido;
}
/**
* Inicia una inversión en un CDT . 
* post: Se cambian los valores del CDT, con los valores recibidos.
 
* @param pMontoInvertido Monto de dinero que se va a invertir en el CDT.
pMontoInvertido > 0.
* @param pInteresMensual Interés mensual que va a ganar el CDT.
pInteresMensual > 0.
* @param pMes Mes de apertura del CDT. pMes > 0.
* @throws Exception
*/
public void invertir( double pMontoInvertido, double pInteresMensual, int
pMes ) throws Exception
{
if(valorInvertido==0 && interesMensual==0 && mesApertura==0) {
valorInvertido = pMontoInvertido;
interesMensual = pInteresMensual;
mesApertura = pMes;
verificarInvariante();
}else {
throw new Exception("ERROR: SOLO SE PUEDE TENER UN CDT ACTIVO A LA
VEZ");
}
/**
* Calcula el valor presente de la inversión teniendo en cuenta el interés de
la cuenta. 
* @param pMesActual Mes actual del simulador. pMesActual > 0.
* @return Valor presente del dinero invertido en CDT.
*/
public double calcularValorPresente( int pMesActual )
{
int mesesTranscurridos = pMesActual - mesApertura;
return ( double ) ( valorInvertido + ( mesesTranscurridos * interesMensual
* valorInvertido ) );
}
public double darIngresoMensualCDT() {

return (double) (interesMensual * valorInvertido);
}
/**
* Cierra el CDT y retorna el valor invertido más los intereses. 
* post: Se retornó el rendimiento del CDT, y se reinició sus atributos
a 0.
* @param pMesActual Mes de cierre para calcular el rendimiento del CDT.
* @return Valor de cierre del CDT.
*/
public double cerrar( int pMesActual )
{
double valorCierre = calcularValorPresente( pMesActual );
valorInvertido = 0;
interesMensual = 0;
mesApertura = 0;
return valorCierre;
}
//TODO: 7 Calcular los intereses del cdt

public double darInteresGenerado(int pMesActual) {
int mesesTranscurridos = pMesActual - mesApertura;
return (double) ( mesesTranscurridos * interesMensual * valorInvertido );
}
public double darIngresosMesescdt(int pMeses) {
return (double) ( pMeses * interesMensual * valorInvertido );
}
private void verificarInvariante() {

assert valorInvertido >=0 : "ERROR: EL VALOR INVERTIDO NO PUEDE SER
NEGATIVO";
assert interesMensual >=0 : "ERROR: EL VALOR INVERTIDO NO PUEDE SER
NEGATIVO";
assert mesApertura >=0 : "ERROR: EL VALOR INVERTIDO NO PUEDE SER NEGATIVO";
}
}
public class CuentaAhorros
{
// -----------------------------------------------------------------
// Atributos
// -----------------------------------------------------------------
/**
* Saldo actual de la cuenta de ahorro.
*/
private double saldo;
/**
* Interés mensual que paga la cuenta de ahorro.
*/
private double interesMensual;
//TODO: 2 Crear atributo

private double interesGenerado;
// -----------------------------------------------------------------
// Métodos
// -----------------------------------------------------------------
/**
* Inicializa la cuenta de ahorro con el interés mensual que paga el banco.
 
* post: Se inicializó el saldo en 0 y el interés mensual en 0.006.
*/
public CuentaAhorros( )
{
saldo = 0;
interesMensual = 0.006;
//TODO: 3 Inicializar el interes generado en 0
interesGenerado = 0;
}
/**
* Retorna el saldo del cliente. 
* @return Saldo de la cuenta de ahorros.
*/
public double darSaldo( )
{
return saldo;
}
/**
* Retorna el interés mensual. 
* @return Interés mensual de la cuenta de ahorros.
*/
public double darInteresMensual( )
{
return interesMensual;
}
//TODO: 4 Retorna el interes total generado

public double darInteresGenerado( )
{
return interesGenerado;
}
/**
* Consigna un monto de dinero en la cuenta del cliente. 
* post: El saldo se incrementó en el monto de dinero ingresado. 
* @param pMonto Monto de dinero a consignar en la cuenta. pMonto > 0.
*/
public void consignarMonto( double pMonto )
{
saldo = saldo + pMonto;
}
/**
* Retira un monto de dinero de la cuenta de ahorros. 
* post: El saldo se redujo en el valor dado.
* @param pMonto Monto de dinero a retirar de la cuenta de ahorros. pMonto > 0.
*/
public void retirarMonto( double pMonto )
{
saldo = saldo - pMonto;
}
/**
* Actualiza el saldo de la cuneta de ahorros sumándole los intereses (ha
pasado un mes). 
* post: El saldo actual se actualizó aplicando el porcentaje de
interés mensual respectivo.
*/
public void actualizarSaldoPorPasoMes( )
{
//TODO: 5 Calcular el ingreso mensual por interes y acumularlo (ahorros)
double ingreso = ( saldo * interesMensual );
saldo += ingreso;
interesGenerado += ingreso;
}
public double darIngresoMensualahorros() {

double ingreso = ( saldo * interesMensual );
return ingreso;
}
//TODO: 6 Calculo interes compuesto

public void actualizarSaldoMeses(int pMeses)
{
interesGenerado += saldo*Math.pow(1+0.006, pMeses) - saldo;
saldo *= Math.pow(1+0.006, pMeses);
public double darIngresoMesesahorros(int pMeses) {

double ingreso = saldo*Math.pow(1+0.006, pMeses) - saldo;
return ingreso;
}
//TODO: 9 Cerrar cuenta de ahorros

public void cerrarCuenta() {
saldo = 0;
}

assert saldo >=0 : "ERROR: EL VALOR SALDO NO PUEDE SER NEGATIVO";
assert interesGenerado >=0 : "ERROR: EL INTERES GENERADO NO PUEDE SER
NEGATIVO";
}
}
public class CuentaCorriente

{
// -----------------------------------------------------------------
// Atributos
// -----------------------------------------------------------------
/**
* Saldo actual de la cuenta corriente.
*/
private double saldo;
// -----------------------------------------------------------------
// Métodos
// -----------------------------------------------------------------
/**
* Inicializa la cuenta corriente. 
* post: Se inicializó el saldo en 0.
*/
public CuentaCorriente( )
{
saldo = 0;
}
/**
* Retorna el saldo de la cuenta del cliente. 
* @return Saldo de la cuenta corriente.
*/
public double darSaldo( )
{
return saldo;
}
/**
* Consigna un monto de dinero en la cuenta del cliente. 
* post: El saldo se incrementó en el monto de dinero dado. 
*/
public void consignarMonto( double pMonto )
{
saldo = saldo + pMonto;
}
/**
* Retira un monto de dinero de la cuenta del cliente. 
* post: El saldo se redujo en el monto de dinero dado.
* @param pMonto Monto de dinero a retirar en la cuenta. pMonto > 0.
*/
public void retirarMonto( double pMonto )
{
saldo = saldo - pMonto;
}
public void cerrarCuenta() {

saldo = 0;
}

assert saldo >=0 : "ERROR: EL VALOR SALDO NO PUEDE SER NEGATIVO";
}
}
@SuppressWarnings("unchecked")
public class SimuladorBancario
{
public static final double INVERSION_MAXIMO = 100000000;
// -----------------------------------------------------------------
// Atributos
// -----------------------------------------------------------------
//TODO: 1 Crear atributo

private double interesGenerado;
/**
* Cédula del cliente.
*/
private String cedula;
/**
* Nombre del cliente.
*/
private String nombre;
/**
* Mes actual.
*/
private int mesActual;
/**
* Cuenta corriente del cliente.
*/
private CuentaCorriente corriente;
/**
* Cuenta de ahorros del cliente.
*/
private CuentaAhorros ahorros;
/**
* CDT del cliente.
*/
private CDT inversion;
private ArrayList<Transaccion> transacciones;
private int consecutivo;
// -----------------------------------------------------------------
// Métodos
// -----------------------------------------------------------------
/**
* Inicializa el simulador con la información del cliente. 
* post: El mes fue inicializado en 1, y las tres cuentas (CDT,
corriente y de ahorros) fueron inicializadas como vacías. 
* @param pCedula Cédula del nuevo cliente. pCedula != null && pCedula != "".
* @param pNombre Nombre del nuevo cliente. pNombre != null && pNombre != "".
*/
public SimuladorBancario( String pCedula, String pNombre )
{
// Inicializa los atributos personales del cliente
nombre = pNombre;
cedula = pCedula;
// Inicializa el mes en el 1
mesActual = 1;
// Inicializa las tres cuentas en vacío
corriente = new CuentaCorriente( );
ahorros = new CuentaAhorros( );
inversion = new CDT( );
consecutivo = 0;
transacciones = new ArrayList<Transaccion>( );
}
/**
* Retorna el nombre del cliente.
* @return Nombre del cliente.
*/
public String darNombre( )
{
return nombre;
}
public ArrayList<Transaccion> darTransacciones() {

return transacciones;
}
public double darInteresGenerado() {
return interesGenerado + ahorros.darInteresGenerado();
}
/**
* Retorna la cédula del cliente.
* @return Cédula del cliente.
*/
public String darCedula( )
{
return cedula;
}
/**
* Retorna la cuenta corriente del cliente.
* @return Cuenta corriente del cliente.
*/
public CuentaCorriente darCuentaCorriente( )
{
return corriente;
}
/**
* Retorna el CDT del cliente.
* @return CDT del cliente.
*/
public CDT darCDT( )
{
return inversion;
}
/**
* Retorna la cuenta de ahorros del cliente.
* @return Cuenta de ahorros del cliente.
*/
public CuentaAhorros darCuentaAhorros( )
{
return ahorros;
}
/**
* Retorna el mes en el que se encuentra la simulación.
* @return Mes actual.
*/
public int darMesActual( )
{
return mesActual;
}
/**
* Calcula el saldo total de las cuentas del cliente.
* @return Saldo total de las cuentas del cliente.
*/
public double calcularSaldoTotal( )
{
return corriente.darSaldo( ) + ahorros.darSaldo( ) +
inversion.calcularValorPresente( mesActual );
}
/**
* Invierte un monto de dinero en un CDT. 
* post: Invirtió un monto de dinero en un CDT.
* @param pMonto Monto de dinero a invertir en un CDT. pMonto > 0.
* @param pInteresMensual Interés del CDT elegido por el cliente.
*/
public void invertirCDT( double pMonto, String pInteresMensual ) throws
Exception
{
double pInteres = Double.parseDouble(pInteresMensual) / 100.0;
inversion.invertir( pMonto, pInteres, mesActual );
consecutivo++;
Transaccion nueva = new Transaccion( Transaccion.TipoCuenta.CDT,
Transaccion.TipoTransaccion.ENTRADA, consecutivo, pMonto );
transacciones.add( nueva );
}
/**
* Consigna un monto de dinero en la cuenta corriente. 
* post: Consignó un monto de dinero en la cuenta corriente.
*/
public void consignarCuentaCorriente( double pMonto )
{
corriente.consignarMonto( pMonto );
consecutivo++;
Transaccion nueva = new Transaccion( Transaccion.TipoCuenta.CORRIENTE,
}
/**
* Consigna un monto de dinero en la cuenta de ahorros. 
* * post: Consignó un monto de dinero en la cuenta de ahorros.
*/
public void consignarCuentaAhorros( double pMonto )
{
ahorros.consignarMonto( pMonto );
consecutivo++;
Transaccion nueva = new Transaccion( Transaccion.TipoCuenta.AHORROS,
}
/**
* Retira un monto de dinero de la cuenta corriente. 
* pre: La cuenta corriente ha sido inicializada
* post: Si hay saldo suficiente, entonces este se redujo en el monto
especificado.
* @param pMonto Monto de dinero a retirar de la cuenta. pMonto > 0.
*/
public void retirarCuentaCorriente( double pMonto )
{
corriente.retirarMonto( pMonto );
consecutivo++;
Transaccion nueva = new Transaccion( Transaccion.TipoCuenta.CORRIENTE,
Transaccion.TipoTransaccion.SALIDA, consecutivo, pMonto );
}
/**
* Retira un monto de dinero de la cuenta de ahorros. 
* post: Se redujo el saldo de la cuenta en el monto especificado.
* @param pMonto Monto de dinero a retirar de la cuenta. pMonto > 0.
*/
public void retirarCuentaAhorros( double pMonto )
{
ahorros.retirarMonto( pMonto );
consecutivo++;
Transaccion.TipoTransaccion.SALIDA, consecutivo, pMonto );
}
/**
* Avanza en un mes la simulación. 
* post: Se avanzó el mes de la simulación en 1. Se actualizó el saldo
de la cuenta de ahorros.
*/
public void avanzarMesSimulacion( )
{
mesActual += 1;
ahorros.actualizarSaldoPorPasoMes( );
if(ahorros.darSaldo()>0) {
consecutivo++;
Transaccion.TipoTransaccion.ENTRADA, consecutivo,
ahorros.darIngresoMensualahorros() );
}
if(inversion.darValorInvertido()>0) {
consecutivo++;
Transaccion nueva2 = new Transaccion( Transaccion.TipoCuenta.CDT,
inversion.darIngresoMensualCDT() );
transacciones.add( nueva2 );
}
/**
* Cierra el CDT, pasando el saldo a la cuenta corriente. 
* pre: La cuenta corriente y el CDT han sido inicializados. 
* post: El CDT quedó cerrado y con valores en 0, y la cuenta corriente
aumentó su saldo en el valor del cierre del CDT.
*/
public void cerrarCDT( )
{
//TODO: 8 agregar el interes generado por el cdt al total de la simulacion
interesGenerado += inversion.darInteresGenerado(mesActual);
double valorCierreCDT = inversion.cerrar( mesActual );
corriente.consignarMonto( valorCierreCDT );
consecutivo++;
Transaccion.TipoTransaccion.SALIDA, consecutivo, valorCierreCDT );
consecutivo++;
Transaccion nueva2 = new Transaccion( Transaccion.TipoCuenta.CORRIENTE,
Transaccion.TipoTransaccion.ENTRADA, consecutivo, valorCierreCDT );
}
/**
* Retrira el saldo total la cuenta de ahorros, pasandolo a la cuenta
corriente. 
* pre: La cuenta corriente y el la cuenta de ahorros han sido
inicializados. 
* post: La cuenta de ahorros queda vacia ( con valores en 0 ), y la
cuenta corriente aumentó su saldo en el valor del saldo total que tenia la cuenta
de ahorros.
*/
public void pasarAhorrosToCorriente()
{
double cantidad = ahorros.darSaldo();
ahorros = new CuentaAhorros();
corriente.consignarMonto(cantidad);
consecutivo++;
Transaccion nueva1 = new Transaccion( Transaccion.TipoCuenta.AHORROS,
Transaccion.TipoTransaccion.SALIDA, consecutivo, cantidad );
consecutivo++;
Transaccion nueva2 = new Transaccion( Transaccion.TipoCuenta.CORRIENTE,
Transaccion.TipoTransaccion.ENTRADA, consecutivo, cantidad );
/**
* Avanza la simulción un numero de meses dado por parámetro.
* @param pMeses numero de meses a avanzar
* post: Se avanzaron los meses de la simulación. Se actualizaron los
saldos.
*/
public void metodo1( int pMeses )
{
mesActual += pMeses;
ahorros.actualizarSaldoMeses(pMeses);
for(int x = 0; x<pMeses;x++) {
if(ahorros.darSaldo()>0) {
consecutivo++;
Transaccion nueva1 = new
Transaccion( Transaccion.TipoCuenta.AHORROS, Transaccion.TipoTransaccion.ENTRADA,
consecutivo, ahorros.darIngresoMesesahorros(pMeses) );
}
if(inversion.darValorInvertido()>0) {
consecutivo++;
inversion.darIngresosMesescdt(pMeses) );
}
/**
* Reinicia la simulación.
* @return interes total generado por la simulación.
*/
public double metodo2( )
{
cerrarCDT();
corriente.cerrarCuenta();
double respuesta = interesGenerado + ahorros.darInteresGenerado();
ahorros.cerrarCuenta();
mesActual = 1;
consecutivo = 0;
transacciones = new ArrayList<Transaccion>( );
return respuesta;
}
public int metodo3(int pTipo, int pCuenta) {
double maximo = 0;
int retornar = 0;
for(Transaccion transaccionactual : transacciones) {

if(transaccionactual.darTipoTransaccion()==pTipo) {
if(transaccionactual.darTipoCuenta()==pCuenta) {
double valor = transaccionactual.darValor();
if (valor>maximo) {
maximo = valor;
retornar = transaccionactual.darConsecutivo();
}
}
}
}
return retornar;

assert interesGenerado >=0 : "ERROR: EL INTERES GENERADO NO PUEDE SER
NEGATIVO";
assert mesActual >=1 : "ERROR: EL MES ACTUAL NO PUEDE SER MENOR QUE 1";
assert corriente != null : "ERROR: LA CUENTA CORRIENTE NO PUEDE SER NULA";
assert ahorros != null : "ERROR: LA CUENTA DE AHORROS NO PUEDE SER NULA";
assert inversion != null : "ERROR: LA INVERSION NO PUEDE SER NULA";
assert (ahorros.darSaldo()+inversion.calcularValorPresente(mesActual)) <=
INVERSION_MAXIMO : "ERROR: SE SUPERÓ EL MONTO MÁXIMO DE INVERSIÓN";
assert consecutivo >=0 : "ERROR: EL CONSECUTIVO NO PUEDE SER NEGATIVO";
}
}
public class Transaccion {
public enum TipoTransaccion {

/**
* Representa el tipo ENTRADA
*/
ENTRADA,
/**
* Representa el tipo SALIDA
*/
SALIDA
}
public enum TipoCuenta {

/**
* Representa el tipo venta
*/
AHORROS,
/**
* Representa el tipo abastecimiento
*/
CORRIENTE,
CDT
}
private int consecutivo;
private double valor;
private TipoTransaccion tipoTransaccion;
private TipoCuenta tipoCuenta;
public Transaccion(TipoCuenta pTipoCuenta, TipoTransaccion pTipoTransaccion,

int pConsecutivo, double pValor) {
tipoCuenta = pTipoCuenta;
tipoTransaccion = pTipoTransaccion;
consecutivo = pConsecutivo;
valor = pValor;
}
public int darConsecutivo() {

return consecutivo;
}
public double darValor() {

return valor;
}
public int darTipoTransaccion(){
return tipoTransaccion.ordinal();
}
public int darTipoCuenta() {

return tipoCuenta.ordinal();
}
public TipoTransaccion darTransaccion() {

return tipoTransaccion;
}
public TipoCuenta darCuenta() {

return tipoCuenta;
}

Reto 5

Cargado por

Copyright:

Formatos disponibles

Reto 5

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Reto 5

Cargado por

Copyright:

Formatos disponibles

// Librerias de java para utilizar

public class CDT

public double darValorInvertido( )

public double darIngresoMensualCDT() {

//TODO: 7 Calcular los intereses del cdt

private void verificarInvariante() {

//TODO: 2 Crear atributo

//TODO: 4 Retorna el interes total generado

public double darIngresoMensualahorros() {

//TODO: 6 Calculo interes compuesto

public double darIngresoMesesahorros(int pMeses) {

//TODO: 9 Cerrar cuenta de ahorros

private void verificarInvariante() {

public class CuentaCorriente

public void cerrarCuenta() {

private void verificarInvariante() {

//TODO: 1 Crear atributo

private ArrayList<Transaccion> transacciones;

private int consecutivo;

public ArrayList<Transaccion> darTransacciones() {

public int metodo3(int pTipo, int pCuenta) {

for(Transaccion transaccionactual : transacciones) {

private void verificarInvariante() {

public class Transaccion {

public enum TipoTransaccion {

public enum TipoCuenta {

private int consecutivo;

private double valor;

private TipoTransaccion tipoTransaccion;

private TipoCuenta tipoCuenta;

public Transaccion(TipoCuenta pTipoCuenta, TipoTransaccion pTipoTransaccion,

public int darConsecutivo() {

public double darValor() {

public int darTipoCuenta() {

public TipoTransaccion darTransaccion() {

public TipoCuenta darCuenta() {

También podría gustarte