Duvida herança [Resolvido]

7 de abril de 2013 8 respostas

robertorp 7 de abril de 2013

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package exerciciopoo;

/**
 *
 * @author Roberto
 */
public class Conta {
    
    private Double saldo = 0.0;
    
    public void deposita(Double saldo)
    {
        this.saldo += saldo;
    }
    
    public void saca(Double valor)
    {
        this.saldo -= valor;
    }
    
    public Double getSaldo()
    {
        return this.saldo;
    }
    
    public void atualiza(Double taxa)
    {
        this.saldo += this.saldo * taxa;
    }
    
    public void nome()
    {
        System.out.println("conta");
    }
            
}

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package exerciciopoo;

/**
 *
 * @author Roberto
 */
public class ContaCorrente extends Conta {
    
    private Double saldo = 0.0;
    
    @Override
    public void atualiza(Double taxa)
    {
        this.saldo += this.saldo * taxa * 2;
    }
    
    @Override
    public void deposita(Double valor)
    {
        this.saldo += valor - 0.10;
    }
    
}

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package exerciciopoo;

/**
 *
 * @author Roberto
 */
public class ContaPoupanca extends Conta {
    
    private Double saldo = 0.0;
    
    @Override
    public void atualiza(Double taxa)
    {
        //System.out.println("1"+ saldo);
        this.saldo += this.saldo * taxa * 3;
    }
    
    @Override
    public void nome()
    {
        System.out.println("conta poupança");
    }
    
}

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package exerciciopoo;

/**
 *
 * @author Roberto
 */
public class ExercicioPOO {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
        
        Conta novaConta =  new ContaPoupanca();
        ContaCorrente contaCorrente = new ContaCorrente();
        ContaPoupanca contaPoupanca = new ContaPoupanca();
        
        novaConta.deposita(1000.0);
        contaCorrente.deposita(1000.0);
        contaPoupanca.deposita(1000.0);
        
        novaConta.atualiza(0.01);
        contaCorrente.atualiza(0.01);
        contaPoupanca.atualiza(0.01);
        
        System.out.println("Conta: " + novaConta.getSaldo());
        System.out.println("Conta Corrente: " + contaCorrente.getSaldo());
        System.out.println("Conta Poupança: " + contaPoupanca.getSaldo());
        
    }
}

retorno do compilador:

Conta: 1000.0
Conta Corrente: 0.0
Conta Poupança: 1000.0

Na conta poupança não deveria ter um aumento de 30? (onde to errando?)
se alguém puder ajudar *-*

8 Respostas

ViniGodoy 7 de abr. de 2013

Por que você está usando o wrapper Double ao invés do tipo primitivo double?

ViniGodoy 7 de abr. de 2013

Seu erro está em redeclarar a variável saldo nas classes filhas. Isso não é necessário, pois elas já foram criadas no pai.

Para usa-las nos filhos, ou você declara como protected, ou então, usa os métodos apropriados do pai (deposita e getSaldo()).

robertorp 7 de abr. de 2013

Meu professor que disse para nos usarmos wrapper
Mas tentei com double, não sei se estou interpretando mal a lógica mas eu acho que deveria ter um aumento na conta poupança não?

ViniGodoy 7 de abr. de 2013

Veja as classes corrigidas:

package exerciciopoo;

public abstract class Conta {
    protected double saldo = 0.0;

    public void deposita(double saldo) {
        this.saldo += saldo;
    }

    public void saca(double valor) {
        saldo -= valor;
    }

    public double getSaldo() {
        return saldo;
    }

    public void atualiza(double taxa) {
        saldo += saldo * taxa;
    }

    public void nome() {
        System.out.println("conta");
    }
}

package exerciciopoo;

public class ContaCorrente extends Conta {
    @Override
    public void atualiza(double taxa) {
        saldo += saldo * taxa * 2;
    }

    @Override
    public void deposita(double valor) {
        saldo += valor - 0.10;
    }
}

package exerciciopoo;

public class ContaPoupanca extends Conta {
    @Override
    public void atualiza(double taxa) {
        saldo += saldo * taxa * 3;
    }

    @Override
    public void nome() {
        System.out.println("conta poupança");
    }
}

package exerciciopoo;

public class ExercicioPOO {
    public static void main(String[] args) {
        Conta novaConta = new ContaPoupanca();
        ContaCorrente contaCorrente = new ContaCorrente();
        ContaPoupanca contaPoupanca = new ContaPoupanca();

        novaConta.deposita(1000.0);
        contaCorrente.deposita(1000.0);
        contaPoupanca.deposita(1000.0);

        novaConta.atualiza(0.01);
        contaCorrente.atualiza(0.01);
        contaPoupanca.atualiza(0.01);

        System.out.println("Conta: " + novaConta.getSaldo());
        System.out.println("Conta Corrente: " + contaCorrente.getSaldo());
        System.out.println("Conta Poupança: " + contaPoupanca.getSaldo());

    }
}

ViniGodoy 7 de abr. de 2013

Ele deu alguma razão para essa idiotice?

robertorp 7 de abr. de 2013

Ele deu alguma razão para essa idiotice?

Somente disse que o gasto de memória não e muito se comparado com as primitivas, visto que temos computadores melhores.

ViniGodoy 7 de abr. de 2013

O problema não é só memória, mas também processamento.
Esse gasto é significativo, especialmente porque sistemas envolvendo doubles costumam a envolver milhares de contas.

Imagine gerenciar um banco, você teria milhares de clientes e milhões de operações dessas por dia.

Além disso, o tipo double admite o valor null, o que nem sempre (ou melhor, quase nunca) é necessário.
Por exemplo, alguém pode erroneamente chamar o método saca(null) e o compilador não avisará do erro.

Finalmente, ainda que o tempo de processamento e o consumo de memória fossem idênticos, não existiria absolutamente nenhuma vantagem em relação ao tipo primitivo double no seu caso.

robertorp 7 de abr. de 2013

O problema não é só memória, mas também processamento.
Esse gasto é significativo, especialmente porque sistemas envolvendo doubles costumam a envolver milhares de contas.

Imagine gerenciar um banco, você teria milhares de clientes e milhões de operações dessas por dia.

Finalmente, ainda que o tempo de processamento e o consumo de memória fossem idênticos, não existiria absolutamente nenhuma vantagem em relação ao tipo primitivo double no seu caso.

Obrigado pela explicação, e pela ajuda!!!

Criado 7 de abril de 2013

Ultima resposta 7 de abr. de 2013

Respostas 8

Participantes 2

8 Respostas

Topicos relacionados