Semana 4 - Fundamentos de Métodos Especiales en Clases: Constructores, Sobrecarga, Encapsulamiento y Métodos de Acceso
Te explicaré cada uno de los conceptos relacionados con los métodos especiales de una clase en programación orientada a objetos, especialmente en lenguajes como Java, Python, C++ o similares. Asumiré que quieres una explicación general y clara, y si necesitas ejemplos en un lenguaje específico, por favor indícalo.
1. Constructores
Un constructor es un método especial de una clase que se utiliza para inicializar objetos cuando se crean. Su propósito principal es asignar valores iniciales a los atributos de la clase.
- Características:
- Tiene el mismo nombre que la clase.
- No tiene tipo de retorno (ni siquiera
void). -
Se ejecuta automáticamente al instanciar un objeto con el operador
new(en lenguajes como Java o C++). -
Ejemplo en pseudocódigo:
class Persona { String nombre; int edad; // Constructor Persona(String nom, int ed) { nombre = nom; edad = ed; } }
2. Sobrecarga de Constructores
La sobrecarga de constructores permite definir múltiples constructores en una misma clase con diferentes parámetros. Esto da flexibilidad al crear objetos de distintas formas.
- Tipos comunes:
- Constructor vacío: Sin parámetros, inicializa los atributos con valores por defecto.
-
Constructor con parámetros: Permite pasar valores específicos al crear el objeto.
-
Ejemplo en pseudocódigo:
class Persona { String nombre; int edad; // Constructor vacío Persona() { nombre = "Sin nombre"; edad = 0; } // Constructor con parámetros Persona(String nom, int ed) { nombre = nom; edad = ed; } } // Uso Persona p1 = new Persona(); // "Sin nombre", 0 Persona p2 = new Persona("Ana", 25); // "Ana", 25 -
Ventaja: La sobrecarga permite crear objetos con diferentes niveles de inicialización según las necesidades.
3. Encapsulamiento e Integridad y Consistencia de Datos
El encapsulamiento es un principio de la programación orientada a objetos que consiste en ocultar los detalles internos de una clase y proteger sus datos. Esto asegura la integridad (los datos no se corrompen) y la consistencia (los datos siempre están en un estado válido).
- Cómo se logra:
- Declarar los atributos como privados (
privateen muchos lenguajes). -
Proveer métodos públicos para acceder o modificar esos atributos (getters y setters).
-
Beneficios:
- Evita que los atributos sean modificados directamente desde fuera de la clase.
-
Permite agregar lógica (validaciones) al modificar o leer datos.
-
Ejemplo en pseudocódigo:
class Persona { private String nombre; private int edad; // Constructor Persona(String nom, int ed) { nombre = nom; edad = ed; } // Métodos públicos controlan el acceso public void setEdad(int ed) { if (ed >= 0) { // Validación edad = ed; } } public int getEdad() { return edad; } }
4. Métodos de Acceso: Getters y Setters
Los getters y setters son métodos públicos que permiten leer (get) y modificar (set) los atributos privados de una clase de forma controlada.
- Getter: Devuelve el valor de un atributo.
-
Setter: Asigna un nuevo valor al atributo, a menudo con validaciones.
-
Ejemplo en pseudocódigo:
class Persona { private String nombre; private int edad; // Constructor Persona(String nom, int ed) { nombre = nom; edad = ed; } // Getter para nombre public String getNombre() { return nombre; } // Setter para nombre public void setNombre(String nom) { if (nom != null && !nom.isEmpty()) { // Validación nombre = nom; } } // Getter para edad public int getEdad() { return edad; } // Setter para edad public void setEdad(int ed) { if (ed >= 0) { // Validación edad = ed; } } } // Uso Persona p = new Persona("Juan", 30); p.setEdad(35); // Cambia edad a 35 System.out.println(p.getNombre()); // Imprime "Juan" -
Notas:
- Los getters suelen ser simples y solo retornan el valor.
- Los setters pueden incluir lógica para validar los datos antes de asignarlos.
Actividad: Diseñar una Clase "CuentaBancaria"
Objetivo: Crear una clase CuentaBancaria que modele una cuenta de banco, implementando constructores, encapsulamiento y métodos de acceso, y luego usarla para realizar operaciones básicas.
Instrucciones Paso a Paso
Paso 1: Definir los atributos privados
- Crea una clase llamada
CuentaBancaria. - Declara los siguientes atributos privados para encapsularlos:
numeroCuenta(tipo String): Identificador único de la cuenta.saldo(tipo double): Cantidad de dinero en la cuenta.titular(tipo String): Nombre del dueño de la cuenta.
Ejemplo en pseudocódigo:
class CuentaBancaria {
private String numeroCuenta;
private double saldo;
private String titular;
}
Paso 2: Crear un constructor vacío
- Implementa un constructor sin parámetros que inicialice los atributos con valores por defecto:
numeroCuenta = "0000".saldo = 0.0.titular = "Sin titular".
Ejemplo en pseudocódigo:
class CuentaBancaria {
private String numeroCuenta;
private double saldo;
private String titular;
// Constructor vacío
public CuentaBancaria() {
numeroCuenta = "0000";
saldo = 0.0;
titular = "Sin titular";
}
}
Paso 3: Crear un constructor con parámetros (sobrecarga)
- Implementa un constructor que acepte los tres atributos como parámetros y los asigne a las variables de la clase.
- Asegúrate de validar que:
- El saldo no sea negativo (si lo es, inicialízalo en 0.0).
- El titular no sea nulo o vacío (si lo es, asigna "Sin titular").
Ejemplo en pseudocódigo:
class CuentaBancaria {
private String numeroCuenta;
private double saldo;
private String titular;
// Constructor vacío
public CuentaBancaria() {
numeroCuenta = "0000";
saldo = 0.0;
titular = "Sin titular";
}
// Constructor con parámetros
public CuentaBancaria(String num, double sal, String tit) {
numeroCuenta = num;
if (sal >= 0) {
saldo = sal;
} else {
saldo = 0.0;
}
if (tit != null && !tit.isEmpty()) {
titular = tit;
} else {
titular = "Sin titular";
}
}
}
Paso 4: Implementar getters y setters
- Crea métodos de acceso para cada atributo:
- Getters:
getNumeroCuenta(),getSaldo(),getTitular(). - Setters:
setNumeroCuenta(),setSaldo(),setTitular(). - Agrega validaciones en los setters:
setSaldo: No permitir saldos negativos.setTitular: No aceptar valores nulos o vacíos.
Ejemplo en pseudocódigo:
class CuentaBancaria {
private String numeroCuenta;
private double saldo;
private String titular;
// Constructores
public CuentaBancaria() {
numeroCuenta = "0000";
saldo = 0.0;
titular = "Sin titular";
}
public CuentaBancaria(String num, double sal, String tit) {
numeroCuenta = num;
if (sal >= 0) {
saldo = sal;
} else {
saldo = 0.0;
}
if (tit != null && !tit.isEmpty()) {
titular = tit;
} else {
titular = "Sin titular";
}
}
// Getters
public String getNumeroCuenta() {
return numeroCuenta;
}
public double getSaldo() {
return saldo;
}
public String getTitular() {
return titular;
}
// Setters
public void setNumeroCuenta(String num) {
numeroCuenta = num;
}
public void setSaldo(double sal) {
if (sal >= 0) {
saldo = sal;
}
}
public void setTitular(String tit) {
if (tit != null && !tit.isEmpty()) {
titular = tit;
}
}
}
Paso 5: Agregar un método adicional
- Implementa un método público
depositar(double cantidad)que aumente el saldo de la cuenta. - Valida que la cantidad a depositar sea positiva.
Ejemplo en pseudocódigo:
public void depositar(double cantidad) {
if (cantidad > 0) {
saldo = saldo + cantidad;
}
}
Paso 6: Probar la clase
- Crea un programa principal (o sección de prueba) donde:
- Instancies una cuenta usando el constructor vacío.
- Instancies otra cuenta usando el constructor con parámetros.
- Usa los setters para modificar el titular de la primera cuenta.
- Realiza un depósito en la segunda cuenta.
- Imprime los datos de ambas cuentas usando los getters.
Ejemplo en pseudocódigo:
class Main {
public static void main() {
// Cuenta con constructor vacío
CuentaBancaria cuenta1 = new CuentaBancaria();
cuenta1.setTitular("Juan Pérez");
cuenta1.depositar(100.0);
// Cuenta con constructor con parámetros
CuentaBancaria cuenta2 = new CuentaBancaria("12345", 500.0, "María López");
cuenta2.depositar(200.0);
// Imprimir resultados
System.out.println("Cuenta 1: " + cuenta1.getNumeroCuenta() + ", " +
cuenta1.getTitular() + ", Saldo: " + cuenta1.getSaldo());
System.out.println("Cuenta 2: " + cuenta2.getNumeroCuenta() + ", " +
cuenta2.getTitular() + ", Saldo: " + cuenta2.getSaldo());
}
}
Salida esperada:
Cuenta 1: 0000, Juan Pérez, Saldo: 100.0
Cuenta 2: 12345, María López, Saldo: 700.0
Paso 7: Reflexión
- Responde las siguientes preguntas:
- ¿Por qué es importante encapsular los atributos como privados?
- ¿Qué ventaja tiene usar constructores sobrecargados en esta clase?
- ¿Cómo aseguran los setters la integridad de los datos?
Variaciones (Opcional)
- Agrega un método
retirar(double cantidad)que disminuya el saldo, asegurándote de que no quede negativo. - Prueba el programa con valores inválidos (saldo negativo, titular vacío) y verifica que las validaciones funcionan.