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

Clase 10 de 27 • Curso de Java

Contenido del curso

Introducción a Java

Conceptos Básicos de Java

Programación Orientada a Objetos en Java

9
Programación Orientada a Objetos en Java: Clases y Objetos
04:47 min
10
Pilares de la Programación Orientada a Objetos: Herencia, Polimorfismo y Encapsulamiento
Viendo ahora
11
Clases Abstractas e Interfaces en Java: Conceptos y Aplicaciones
03:44 min
12
Patrones de Diseño en Programación Orientada a Objetos con Java
06:18 min

Manejo de Excepciones y File I/O

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

Pruebas y Depuración

Características Avanzadas de Java

Programación Concurrente

Tomar examen

Comentarios

iecgerman .

student•

No me está gustando el curso y eso creo que está haciendo que deteste JAVA, o mejor dicho la forma en como están dando el curso no me gusta, esta como robotizado, o como cuando en la escuela pasaba a dar clase un compañero y ponía sus diapositivas de power point y el comenzaba a leer todo sin sentido.

iecgerman .

student•

Me vino a la mente un profe que decía, no sólo van a tener que saber programar, se van a meter en el papel del cajero, de los clientes, del almacenista, de logística, de los proveedores, etc.

me faltaría lo del checking pero no sé qué poner de atributos o que hacer, según yo es para cuenta de cheques.

aquí sólo disque puse lo de Fixed Deposit que es depósitos a plazo fijo

# Esto es herencia porque estamos llamando a la super clase Account y reutilizando sus atributos accountNumber, intialBalance
public class FixedDepositAccount extends Account { # seria un deposito fijo que recibe un interes fijo cada mes al no sacar el dinero
    private double interestFixedDeposit; 

    public FixedDepositAccount(String accountNumber, double initialBalance, double interestFix) {
        super(accounNumber, initialBalance); 
        this.interestFixedDeposit = interestFixedDeposit
    }

    public void applyInterestFixed() {
        double interest = getBalance() * interestFixedDeposit
        deposit(interest);
    }
}
```															&#x9;

Gerardo Rubio Camacho

student•

Solamente es este curso, ntp. En los demás cursos si explica gente y no IA aún.

Antonio Demarco Bonino

student•

Resumen:

Herencia: Permite que una clase hija herede atributos y métodos de una clase padre. Facilita la reutilización del código y la especialización de clases.
Polimorfismo: Permite que un objeto adopte muchas formas. En tiempo de ejecución, permite que los métodos sobrescritos se comporten de manera diferente según la subclase que los implemente.
Encapsulación: Permite ocultar los detalles internos de una clase y controlar el acceso a sus atributos mediante métodos públicos. Mejora la seguridad y la integridad del código.

Manuel Galindo

student•

El polimorfismo se refiere a la capacidad de los objetos de diferentes clases de ser tratados como objetos de una clase común. En términos simples, polimorfismo significa “muchas formas”. Este concepto permite que un mismo método o función se comporte de manera diferente según el objeto que lo invoque.

michaelbeltran80@gmail.com motivar

student•

Hola gracias por el contenido, a pesar de los comentarios que veo a mi me parece buen formato, es una forma de prestar atencion tanto auditivamente como de lectura lo cual facilita que el foco sea mayor!!

Julio Bastidas

student•

hay un error en esta clase, no se reproduce nada

luis alfredo llanos fuentes

student•

este formato no es el indicado para aprender, quiza sirve si se desea repasar un tema ya conocido

Nicolas Dario Miranda Riveros

student•

Si sos nuevo, conviene mucho más ir por este curso que explican a detalle y es mas llevadero: https://platzi.com/cursos/java-oop/ y tener este para repasar luego.

Manuel Galindo

student•

La encapsulación es un principio fundamental en la programación orientada a objetos (POO) y juega un papel crucial en el desarrollo de software en Java. Este concepto se refiere a la práctica de agrupar datos (atributos) y métodos (comportamientos) que operan sobre esos datos dentro de una sola unidad, llamada clase. Al hacerlo, se crea una barrera protectora alrededor de los datos, lo que impide el acceso directo desde fuera de la clase y asegura que solo los métodos definidos puedan interactuar con ellos.

Una de las principales ventajas de la encapsulación es la protección de datos. Al declarar los atributos de una clase como privados y proporcionar métodos públicos para acceder y modificar esos datos (conocidos como getters y setters), se controla cómo se accede y se modifica la información. Esto previene modificaciones accidentales o incorrectas desde otras partes del programa, lo que puede llevar a errores difíciles de detectar y corregir.

Daniel Eduardo Rojas Pulido

student•

Este formato es horrible, no me está gustando nada, va muy rápido todo, no puedo seguir las clases adecuadamente porque no veo cómo es el paso a paso, qué curso tan horroroso

Gino Anderson Moreno Bejarano

student•

// Clase base
class Animal {
    // Atributo privado
    private String nombre;

    // Constructor
    public Animal(String nombre) {
        this.nombre = nombre;
    }

    // Método para hacer sonar al animal
    public void hacerSonido() {
        System.out.println("El animal hace un sonido.");
    }
}

// Clase derivada que hereda de Animal
class Perro extends Animal {
    // Constructor
    public Perro(String nombre) {
        super(nombre); // Llama al constructor de la clase base
    }

    // Sobrescribe el método hacerSonido
    @Override
    public void hacerSonido() {
        System.out.println("El perro ladra.");
    }
}

// Clase principal para probar la herencia
public class Main {
    public static void main(String[] args) {
        Animal miAnimal = new Animal("Animal Genérico");
        miAnimal.hacerSonido(); // Salida: El animal hace un sonido.

        Perro miPerro = new Perro("Rex");
        miPerro.hacerSonido(); // Salida: El perro ladra.
    }
}

Este código ilustra la herencia en Java. La clase Perro hereda de Animal, reutilizando el constructor y sobrescribiendo el método hacerSonido. Esto muestra cómo se pueden extender las funcionalidades de una clase base.

Marcos Vázquez González

student•

Más que un curso que te va a enseñar algo es la explicación de una aplicación que se ejecuta desde la consola, como el alumno de 2do semestre que entrega el proyecto y le explica al docente lo que hizo explicando los términos vistos en el curso jaja

Jefferson Pino

student•

No carga el video.

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

}

John Kennedy Landazuri Sandoval

student•

My FixedDepositAccount version

public class FixedDepositAccount extends Account { private double interestRate; private int maturityPeriod; // in months 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; deposit(interest); } else { throw new IllegalStateException("Account is not matured yet."); } }

public void mature() { isMatured = true; }

public boolean isMatured() { return isMatured; }

public double getInterestRate() { return interestRate; }

public int getMaturityPeriod() { return maturityPeriod; } }

John Kennedy Landazuri Sandoval

student•

Mi CheckingAccount version

import exception.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 > getBalance() + overdraftLimit) { throw new InsufficientFundsException("Withdrawal exceeds overdraft limit."); } super.withdraw(amount); }

public double getOverdraftLimit() { return overdraftLimit; } }

Ricardo González Navarro

student•

hay algún curso de java donde se vea el flujo de los archivos de cada capitulo? la verdad no supe donde va cada codigo en el nuevo editor que ofrecen aqui, yo solo eh usado virtal estudio

Diego Nicolas Barboza

student•

busca los cursos de JACA SE,la profe es lo mejor

ANDRES ALFONSO MIRA MEJIA

student•

✅

Luis Insuasti

student•

ME ENCANTÓ ESTE FORMATO DE VIDEOS , EN VEZ DE VER LA CARA DE ALGUIEN PREFIERO VER EL TEXTO

Manuel Galindo

student•

Cuatro ventajas de la herencia en Java:

Reutilización de código: Las subclases pueden utilizar el código de las superclases, lo que evita la duplicación de código y facilita su mantenimiento.
Facilita el mantenimiento: Al tener un código centralizado en las superclases, cualquier cambio o corrección se realiza en un solo lugar, lo que simplifica el mantenimiento.
Extensibilidad: Permite crear nuevas clases basadas en clases existentes, facilitando la expansión y evolución de las aplicaciones.
Organización y claridad: Ayuda a mantener el código más limpio y organizado, ya que las relaciones entre clases están claramente definidas.

Gerald de Jesús González Zeledón

student•

A pesar de las ventajas que puede tener recuerda la composición sobre herencia

# Esto es herencia porque estamos llamando a la super clase Account y reutilizando sus atributos accountNumber, intialBalance
public class FixedDepositAccount extends Account { # seria un deposito fijo que recibe un interes fijo cada mes al no sacar el dinero
    private double interestFixedDeposit; 

    public FixedDepositAccount(String accountNumber, double initialBalance, double interestFix) {
        super(accounNumber, initialBalance); 
        this.interestFixedDeposit = interestFixedDeposit
    }

    public void applyInterestFixed() {
        double interest = getBalance() * interestFixedDeposit
        deposit(interest);
    }
}
```															&#x9;

// Clase base
class Animal {
    // Atributo privado
    private String nombre;

    // Constructor
    public Animal(String nombre) {
        this.nombre = nombre;
    }

    // Método para hacer sonar al animal
    public void hacerSonido() {
        System.out.println("El animal hace un sonido.");
    }
}

// Clase derivada que hereda de Animal
class Perro extends Animal {
    // Constructor
    public Perro(String nombre) {
        super(nombre); // Llama al constructor de la clase base
    }

    // Sobrescribe el método hacerSonido
    @Override
    public void hacerSonido() {
        System.out.println("El perro ladra.");
    }
}

// Clase principal para probar la herencia
public class Main {
    public static void main(String[] args) {
        Animal miAnimal = new Animal("Animal Genérico");
        miAnimal.hacerSonido(); // Salida: El animal hace un sonido.

        Perro miPerro = new Perro("Rex");
        miPerro.hacerSonido(); // Salida: El perro ladra.
    }
}

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

}

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