Dúvida no Ex. 7 da Aula 2 - Herança, reescrita e polimorfismo

Lincoln, Tudo bem? Deixe-me saber uma coisa, está tudo escrito em um único arquivo?

Caso sim, separe a classe AtualizadorDeContas em um outro arquivo e declare-a como pública. Dessa forma.

public class AtualizadorDeContas{
 ///restante do codigo da classe aqui dentro.
}

Olá Wanderson! conforme a sua sugestão, o exercício 7 deve rodar como um código único? em um arquivo único, separado do restante que vem sendo ampliado no decorrer das aulas anteriores?

O meu código ficou assim depois de algumas correções:

public class ClienteConta {
    protected double saldo;
    protected double taxa;
    public void deposita(double valor){
        this.saldo += valor;
    }
    public void saca (double valor){
        this.saldo -= valor;
    }
    public void atualiza (double taxa){
        this.saldo += this.saldo * taxa;
    }
    protected double getSaldo(){
        return saldo;
    }
    class ContaCorrente extends ClienteConta{
        public double getSaldo(ClienteConta cc){
            return this.saldo * 0.20;
        }
    }
    class ContaPoupanca extends ClienteConta{
        public double getSaldo(ClienteConta cp){
            return this.saldo * 0.30;
        }
    }
}
class AtualizadorDeContas {
    private double saldoTotal = 0;
    private double selic;
    public AtualizadorDeContas(double selic) {
        this.selic = selic;
    }
    public double getSaldoTotal(){
        return this.saldoTotal;
    }
    public void roda(ClienteConta c) {
        System.out.println("==============================");
        System.out.println("saldo anterior:" + c.getSaldo());
        c.atualiza(this.selic);
        System.out.println("saldo atualizado: " + c.getSaldo());
        this.saldoTotal += c.getSaldo();
    }

    public static void main(String[] args) {
        ClienteConta c = new ClienteConta();
        ClienteConta cc = new ClienteConta();
        ClienteConta cp = new ClienteConta();
        c.deposita(1000);
        cc.deposita(1000);
        cp.deposita(1000);
        AtualizadorDeContas adc = new AtualizadorDeContas(0.01);
        adc.roda(c);
        adc.roda(cc);
        adc.roda(cp);
        System.out.println("Saldo Total: " + adc.getSaldoTotal());
    }
}

e o resultado depois de compilado foi esse:

==============================
saldo anterior:1000.0
saldo atualizado: 1010.0
==============================
saldo anterior:1000.0
saldo atualizado: 1010.0
==============================
saldo anterior:1000.0
saldo atualizado: 1010.0
Saldo Total: 3030.0

@Lincoln, editei sua última mensagem para formatar como código.

Identifiquei alguns problemas no seu código:

Como as classes ContaPoupanca e ContaCorrente foram declaradas dentro da classe ClienteConta, você não conseguiria utilizá-las no seu AtualizadorDeContas. Para que isso funcione, você precisa declará-las fora da classe ClienteConta.

Você tentou sobrescrever o método getSaldo() nas classes ContaCorrente e ContaPoupanca, mas não conseguiu, pois você mudou a assinatura do método: o método da classe mãe é double getSaldo() mas nas filhas você mudou para double getSaldo(ContaXXX conta). Esse parâmetro não é necessário. Aliás, se sua intenção é sobrescrever o método getSaldo() da classe ClienteConta, ele está errado mesmo. Para sobrescrever, é necessário que o método na classe filha tenha a mesma assinatura, ou seja, o mesmo tipo de retorno (double), o mesmo nome (getSaldo) e os mesmos parâmetros (nenhum).

O código corrigido, simplificado (sem as partes não mexidas), fica assim:

public class ClienteConta {
    // codigo da classe cliente conta aqui,
    // SEM as classes ContaCorrente e ContaPoupanca
}
class ContaCorrente extends ClienteConta {
    // repare que este metodo não recebe mais um parâmetro
    public double getSaldo() {
        return this.saldo * 0.20;
    }
}
class ContaPoupanca extends ClienteConta{
    // nem este!
    public double getSaldo() {
        return this.saldo * 0.30;
    }
}
class AtualizadorDeContas {
    // resto do codigo do atualizador de contas aqui..

    public static void main(String[] args) {
        // para usar uma conta normal, você cria um
        // objeto da classe ClienteConta
        ClienteConta c = new ClienteConta();
        // para usar uma conta corrente,
        //crie um objeto ContaCorrente
        ClienteConta cc = new ContaCorrente();
        // para usar uma poupanca,
        // crie um objeto ContaPoupanca
        ClienteConta cp = new ContaPoupanca();
        c.deposita(1000);
        cc.deposita(1000);
        cp.deposita(1000);
        AtualizadorDeContas adc = new AtualizadorDeContas(0.01);
        adc.roda(c);
        adc.roda(cc);
        adc.roda(cp);
        System.out.println("\nSaldo Total: " + adc.getSaldoTotal());
    }
}

Assim, a saída do seu programa será a seguinte:

==============================
saldo anterior:1000.0
saldo atualizado: 1010.0
==============================
saldo anterior:200.0
saldo atualizado: 202.0
==============================
saldo anterior:300.0
saldo atualizado: 303.0

Saldo Total: 1515.0

Os valores são muito mais baixos por que a sobrescrição funcionou e portanto ao chamar o método getSaldo(), você estará chamando o método modificado que multiplica o saldo por 0.2 e 0.3 (de acordo com a classe instanciada).

Deu pra entender?

Se sim, marque a resposta como solução! Se não, insista que eu ou outros continuaremos tentando te ajudar =)

Lincoln, por boa prática sempre crie as classes em arquivos separados e declareas como public. Assim evita esses tipos de erros que você encontrou, onde o java não consegue 'encontrar' sua classe.

O erro que resolve o problema que o fez vir ao forum foi relacionado a isso. Porém como o Marco já falou acima, seu código tem outros problemas. Não procure somente corrigil-los, mas também entender o motivo de cada correção.

Espero ter ajudado! Bons Estudos.

Obrigado pelas explicações!