Hola, compañero. Me pasó exactamente igual; las clases Cliente y Cuenta cambiaron en esta aula. Permíteme darte una explicación:
- Para Cliente NO cambió nada (al menos según lo que vi en esta aula y lo que tengo).
- Para Cuenta cambió lo siguiente:
- Al código actual le agregaron un parámetro más al constructor de Cuenta, el cual es numero. Y pues, dentro del constructor se asigna el valor numero al atributo this.numero de la clase de Cuenta. Cabe aclarar que también lo simplificaron mucho más, pues ya no hacían uso de condicionales (if, como se tenía en el proyecto anterior).
//CÓDIGO ANTES:
public Cuenta(int agencia) {
if(agencia <=0) {
System.out.println("Valor de agencia invalido. Se le asigna 1 por defecto");
this.agencia = 1;
}else {
this.agencia = agencia;
}
total++;
System.out.println("Van creadas: "+total+" cuentas");
}
//CÓDIGO AHORA:
public Cuenta(int agencia, int numero) {
this.agencia = agencia;
this.numero = numero;
total++;
System.out.println("Van creadas: "+total+" cuentas");
}
- También me di cuenta que el método transferir de la clase Cuenta (del proyecto anterior) cambió ligeramente. Si te percatas, en el código actual cuando al atributo saldo le van a restar el valor que se quiere transferir, ya no lo hacen directamente con la variable valor (como se hizo en el proyecto anterior, o sea, this.saldo -= valor;), sino que implementan el método retirar (this.retirar(valor);), esto lo hacen por la aplicación que se le dio al código según la explicación del aula.
//CÓDIGO ANTERIOR
public boolean transferir(double valor, Cuenta cuenta) {
if (this.saldo >= valor) {
this.saldo -= valor;
cuenta.depositar(valor);
return true;
}
return false;
}
//CÓDIGO ACTUAL
public boolean transferir(double valor, Cuenta cuenta) {
if (this.saldo >= valor) {
this.retirar(valor);
cuenta.depositar(valor);
return true;
}
return false;
}
Finalmente, dando continuidad a la explicación del concepto de polimorfismo en esta aula, se crearon dos clases (CuentaCorriente y CuentaAhorros). Ambas clases implementaron o digamos que "heredaron" el constructor de la clase Cuenta. Lo que hay que destacar es que en CuentaCorriente crearon el siguiente override (o sobreescribir) del método retirar, que también está en la clase Cuenta (por cierto, en el proyecto actual se llama ahora saca, y yo siempre lo tuve como retirar).
public boolean retirar(double valor) {
double comision = 0.2;
return super.retirar(valor + comision);
}
Cuando se quiere implementar los cambios realizados (del método transferir y el override de retirar - o saca, según el aula-), crearon la clase TestCuenta:
public class TestCuenta {
public static void main(String[] args) {
CuentaCorriente cc = new CuentaCorriente(1, 1);
CuentaAhorros ca = new CuentaAhorros(2, 3);
cc.depositar(2000);
cc.transferir(1000, ca);
System.out.println(cc.getSaldo());
System.out.println(ca.getSaldo());
}
}
Con base a TODO lo anterior, cuando implementan cc.transferir(1000, ca); pasa lo siguiente, en cuanto al polimorfismo:
- Dentro del método transferir (que está en la clase Cuenta) se implementa el método retirar, pero ojo, el programa se adapta o responde en función de la invocación o contexto, es decir, NO se implementaría el método retirar que está en la clase Cuenta, sino que en realidad se implementaría el método retirar que está en la clase hija (en este ejemplo, CuentaCorriente). Y es ahí cuando se establece la comisión y luego ahí sí se invoca el método retirar de la clase Cuenta (usando el return super.retirar(valor + comision);), para finalmente restar el valor a transferir junto con la comisión.
Espero haber sido claro con la explicación. Todo lo que dije fue lo que entendí jeje. Cualquier cosa podemos seguir discutiendo este topic. Mucha suerte, compañero :)