[Resolvido] Método construtor x herança

Quando você chama super() sem argumentos, ele invocará o construtor da superclasse que esteja sem argumentos, se não houver, usará um construtor padrão.

Para invocar o construtor que você definiu, tem que colocar os parâmetros.

marcos@marcos:

Pessoal, criei a seguinte classe:

package metodositerativos;

public abstract class calculaRaizes {
    protected double tolerancia;//armazena a precisão desejada (ex.: 0,001)
    protected double posInicial;//intervalo inicial Ri
    protected double posFinal;//intervalo final Si
    protected double raiz;
    protected int num_exercicio;
    protected int contador;
    
    //método construtor
    public calculaRaizes(double tol,double inicio, double fim, int num) {
        posInicial = inicio;
        posFinal = fim;
        this.contador = 0;
        this.tolerancia = tol;
        this.num_exercicio = num;
    }
    
    abstract void encontraRaizFuncao();
    
    public void calcula(){
         encontraRaizFuncao();
     }
     
     public int getContador(){
         return this.contador;
     }
     
     public double getResultado(){
         return ((posInicial+posFinal)/2);
     }
    
}

Depois, especializei assim:

package metodositerativos;

public class bissecao extends calculaRaizes{
    
    bissecao(double tol,double inicio, double fim, int num){
        super(tol,inicio,fim,num);
    }
        
    @Override
    void encontraRaizFuncao() {
        double temp3=0;        
        do{
           raiz = (posInicial+posFinal )/2;           
           switch(num_exercicio){
               case 1:
                   temp3 = (Math.pow(Math.E,(-(raiz*raiz)))-(Math.cos(raiz)));
                   break;
               case 2:
                   temp3 = raiz+Math.log(raiz);
                   break;
           }           
           
           if(temp3<0){
               posInicial = raiz;}
           else{
               posFinal = raiz;}
           
          contador++;          
        }while(posFinal-posInicial>this.tolerancia);        
    
}
    
}

Porém estou em dúvida quanto a esta parte:

bissecao(double tol,double inicio, double fim, int num){ super(tol,inicio,fim,num); }

Não bastaria apenas um

super();

?

Do jeito que fiz criei um método construtor na classe filha e voltei a invocar o construtor da classe pai... gente me dá uma dica, que me enrolei todo aqui!!!

Se você utilizar o Super(), ele vai invocar o construtor padrão da classe mãe, e como você não especificou esse construtor padrão ele não vai fazer nada.

Como a sua classe mãe é abstract, ou seja, não pode ser instanciado um objeto da mesma.

bissecao(double tol,double inicio, double fim, int num){  
        super(tol,inicio,fim,num);  
    }

Aqui você está apenas criando uma maneira de transferir os parâmetros da classe filha para utilizar no construtor da classe Mãe.

Eu acredito que se não tiver um objetivo por trás dessas classes, como por exemplo, conceitos que algum livro queira te passar, eu não criaria essa classe como Abstract , e colocaria esses cálculos diferenciados utilizando sobrecarga dos construtores ou métodos.

Espero ter ajudado.

Artur Martini

Artur, mas pra que eu faça a sobrescrita de um método essa classe precisaria ser abstrata, não?! Ou na assinatura do método não devo definir que é abstract então, correto?

No algoritmo que estou desenvolvendo, a única coisa que mudará é o método [color=red]encontraRaizFuncao()[/color], até por isso que optei por trabalhar com herança, pra que apenas sobrescrevesse o que realmente mudará, visando economizar código. Pretendia forçar que tal método seja implementado.

Você poderia me dar um exemplo de como ficaria sobrescrevendo o método?

Será apenas sobrescrever o método na classe filha mesmo?

Devo fazer assim então:

protected void encontraRaizFuncao(){};

e na especialização, assim:

@Override
    protected void encontraRaizFuncao() {
        double temp3=0;        
        do{
           raiz = (posInicial+posFinal )/2;           
           switch(num_exercicio){
               case 1:
                   temp3 = (Math.pow(Math.E,(-(raiz*raiz)))-(Math.cos(raiz)));
                   break;
               case 2:
                   temp3 = raiz+Math.log(raiz);
                   break;
           }           
           
           if(temp3<0){
               posInicial = raiz;}
           else{
               posFinal = raiz;}
           
          contador++;          
        }while(posFinal-posInicial>this.tolerancia);        
    
}

Dessa forma estaria de acordo com as boas práticas de programação (além de resolver o problema proposto)?

marcos@marcos:

Artur, mas pra que eu faça a sobrescrita de um método essa classe precisaria ser abstrata, não?! Ou na assinatura do método não devo definir que é abstract então, correto?

No algoritmo que estou desenvolvendo, a única coisa que mudará é o método [color=red]encontraRaizFuncao()[/color], até por isso que optei por trabalhar com herança, pra que apenas sobrescrevesse o que realmente mudará, visando economizar código. Pretendia forçar que tal método seja implementado.

Você poderia me dar um exemplo de como ficaria sobrescrevendo o método?

Será apenas sobrescrever o método na classe filha mesmo?

Olá Marcos.

Acho que você não entendeu, vou tentar me expressar de outra forma.

Eu falei para você esquecer da classe filha e herança, ou seja, nem implemente a classe bissecao.

Levando em consideração essa frase:
No algoritmo que estou desenvolvendo, a única coisa que mudará é o método [color=red]encontraRaizFuncao()[/color], até por isso que optei por trabalhar com herança, pra que apenas sobrescrevesse o que realmente mudará, visando economizar código. Pretendia forçar que tal método seja implementado.

Você mesmo diz que a unica coisa que muda é o método [color=red]encontraRaizFuncao()[/color], mas você vai criar outra classe apenas para implementar outra variação desse mesmo método, porque não utiliza sobreCARGA e elimina a parte de herança, ou simplesmente coloque outro nome no método, ai sim estou vendo vantagem.

Mas criar uma outra classe e precisar utilizar herança apenas para implementar um método, não acho legal.

Vou passar outros detalhes, não sei se isso altera a forma de ver a implementação.

Na verdade preciso implementar três métodos de resoluções de equações (método da bisseção, iterações lineares, método de newton) para duas funções já pré-definidas.