Pilares de la Programación Orientada a Objetos: Herencia, Polimorfismo y Encapsulamiento

Pedro Roberto Capriles Morales

student•

Agrego un acercamiento a las clases FixedDepositAccount y CheckingAccount con los tests unitarios, el codigo completo lo puede obtener desde el siguiente repositorio:

package org.example;

import org.example.utils.errorHandle.InsufficientFundsException;

public class CheckingAccount extends Account {
    private double overdraftLimit;

    public CheckingAccount(String accountNumber, double initialBalance, double overdraftLimit) {
        super(accountNumber, initialBalance);
        this.overdraftLimit = overdraftLimit;
    }

    @Override
    public void withdraw(double amount) throws InsufficientFundsException {
        if (amount > this.getBalance() + overdraftLimit) {
            throw new InsufficientFundsException();
        }
        this.setBalance(this.getBalance() + overdraftLimit - amount);
    }

    public double getOverdraftLimit() {
        return overdraftLimit;
    }

    public void setOverdraftLimit(double overdraftLimit) {
        this.overdraftLimit = overdraftLimit;
    }
}

``````js
package org.example;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;

import java.io.ByteArrayOutputStream;
import java.io.PrintStream;

import org.example.utils.errorHandle.InsufficientFundsException;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;

public class CheckingAccountTest {
    private final ByteArrayOutputStream outContent = new ByteArrayOutputStream();
    private final PrintStream originalOut = System.out;
        @BeforeEach
    void setUpStreams() {
        System.setOut(new PrintStream(outContent));
    }

    @AfterEach
    void restoreStreams() {
        System.setOut(originalOut);
    }

    @Test
    public void testWithdrawWithOverdraft() throws InsufficientFundsException {
        CheckingAccount checkingAccount = new CheckingAccount("123456789", 500, 200);
        checkingAccount.withdraw(600);
        checkingAccount.showBalance();
        String expectedBalance = "Current balance: 100.0";

        assertTrue(outContent.toString().contains(expectedBalance));

    }

    @Test
    public void testWithdrawExceedingOverdraft() {
        CheckingAccount checkingAccount = new CheckingAccount("123456789", 500, 200);
        try {
            checkingAccount.withdraw(800); // Should throw InsufficientFundsException
        } catch (InsufficientFundsException e) {
            // Expected exception
        }
    }

    @Test
    public void testGetOverdraftLimit() {
        CheckingAccount checkingAccount = new CheckingAccount("123456789", 500, 200);
        double expectedOverdraftLimit = 200;
        
        double overdraftLimit = checkingAccount.getOverdraftLimit();
        
        assertEquals(overdraftLimit, expectedOverdraftLimit);
    }

    @Test
    public void testSetOverdraftLimit() {
        CheckingAccount checkingAccount = new CheckingAccount("123456789", 500, 200);
        double newOverdraftLimit = 300;
        
        checkingAccount.setOverdraftLimit(newOverdraftLimit);
        
        assertEquals(checkingAccount.getOverdraftLimit(), newOverdraftLimit);
    }
}

``````js
package org.example;

public class FixedDepositAccount extends Account {
    private double interestRate;
    private int maturityPeriod;
    private boolean isMatured;

    public FixedDepositAccount(String accountNumber, double initialBalance, double interestRate, int maturityPeriod) {
        super(accountNumber, initialBalance);
        this.interestRate = interestRate;
        this.maturityPeriod = maturityPeriod;
        this.isMatured = false;
    }

    public void applyInterest() {
        if (isMatured) {
            double interest = getBalance() * interestRate / 100;
            deposit(interest);
        } else {
            throw new IllegalStateException("Account is not matured yet.");
        }
    }

    public void mature() {
        isMatured = true;
    }

    public boolean isMatured() {
        return isMatured;
    }

    public int getMaturityPeriod() {
        return maturityPeriod;
    }
    
}

``````js
package org.example;

import static org.junit.jupiter.api.Assertions.assertEquals;

import org.junit.jupiter.api.Test;

public class FixedDepositAccountTest {
    @Test
    public void testFixedDepositAccount() {
        // Create a FixedDepositAccount with a specific maturity period and interest rate
        FixedDepositAccount fixedDepositAccount = new FixedDepositAccount("FD123456", 10000, 0.07, 12);
        
        // Check initial balance
        assertEquals(10000, fixedDepositAccount.getBalance());
    
        
        fixedDepositAccount.mature();
        fixedDepositAccount.applyInterest();
        
        double expectedBalance = 10007;
        assertEquals(expectedBalance, fixedDepositAccount.getBalance());
    }

}

iecgerman .

Gerardo Rubio Camacho

Antonio Demarco Bonino

Manuel Galindo

michaelbeltran80@gmail.com motivar

Julio Bastidas

luis alfredo llanos fuentes

Nicolas Dario Miranda Riveros

Daniel Eduardo Rojas Pulido

Gino Anderson Moreno Bejarano

Marcos Vázquez González

Jefferson Pino

John Kennedy Landazuri Sandoval

Ricardo González Navarro

Diego Nicolas Barboza

ANDRES ALFONSO MIRA MEJIA

Luis Insuasti

Gerald de Jesús González Zeledón

Pilares de la Programación Orientada a Objetos: Herencia, Polimorfismo y Encapsulamiento

Introducción a Java

Programación en Java: Del Fundamento al Desarrollo de JavaBank

Instalación y configuración de JDK e IntelliJ para Java

Creación y ejecución de programas Java: clases y método main

Control de Versiones con Git: Fundamentos y Aplicación Práctica

Conceptos Básicos de Java

Variables, Tipos de Datos y Operadores en Java para Cajeros Automáticos

Control de Flujo en Cajeros Automáticos con Java

Manejo de Arrays y Colecciones en Java para Programas Bancarios

Crear una calculadora en Java e integrarla con JavaBank

Programación Orientada a Objetos en Java

Programación Orientada a Objetos en Java: Clases y Objetos

Pilares de la Programación Orientada a Objetos: Herencia, Polimorfismo y Encapsulamiento

Clases Abstractas e Interfaces en Java: Conceptos y Aplicaciones

Patrones de Diseño en Programación Orientada a Objetos con Java

Manejo de Excepciones y File I/O

Manejo de errores en Java con try-catch y excepciones personalizadas

Manejo de Excepciones Checked y Unchecked en Java

Lectura y Escritura de Archivos en Java para Registros Bancarios

Eficiencia con Streams en Java para Operaciones de Entrada y Salida

Biblioteca Estándar de Java y Herramientas de Construcción

Manipulación Avanzada de Strings y Colecciones en Java

Fundamentos de Generics en Java para Sistemas Bancarios

Comparación y Uso Avanzado de Maven y Gradle en Java

Pruebas y Depuración

Pruebas Unitarias con JUnit y TestNG en Java

Técnicas de Depuración en Java: Breakpoints, Mensajes y Logging

Integración de Pruebas en Desarrollo JavaBank

Características Avanzadas de Java

Expresiones Lambda y Functional Interfaces en Java 8

Procesamiento de Datos con Stream API en Java

Manejo Seguro de Valores Nulos y API de Fecha/Tiempo en Java

Programación Concurrente

Concurrencia y Multithreading en Java: Gestión y Sincronización de Hilos

Concurrencia Asíncrona con CompletableFuture en Java