Olá pessoal,
eu queria algumas opiniões
sobre o uso de classe abstrata
Eu tenho uma classe abstrata:
public abstract class Analise{
protected double resultado;
//Construtor
protected Analise(){
resultado = 0;
}
protected Analise(double resultado){
this.resultado = resultado;
}
/**
* O método getResultado é publico porque
* precisará ser acessado direto na instância,
* ou seja, não há implementação deste método
* nas classes filhas.
*/
public double getResultado(){
return resultado;
}
}
e tenho outra classe Extrato Seco:
public class ExtratoSeco extends Analise {
private double pesoAntes;
private double pesoDepois;
public ExtratoSeco(){
super();
}
...
public void calculaExtratoSeco(){
resultado = (this.pesoDepois - this.pesoAntes) * 40;
}
...
}
Eu gostaria de saber se é correto fazer
isso o que eu fiz, usei direto
o atributo resultado da classe
abstrata Analise para receber
o valor do cálculo no método
calculaExtratoSeco?
public interface Analise{
/**
* O método getResultado é publico porque
* precisará ser acessado direto na instância,
* ou seja, não há implementação deste método
* nas classes filhas.
*/
double getResultado();
}
[code]
public class ExtratoSeco implements Analise {
private double pesoAntes;
private double pesoDepois;
[quote=ViniGodoy]Sim, é correto. Mas pq não usar uma interface?
public interface Analise{
/**
* O método getResultado é publico porque
* precisará ser acessado direto na instância,
* ou seja, não há implementação deste método
* nas classes filhas.
*/
double getResultado();
}
[code]
public class ExtratoSeco implements Analise {
private double pesoAntes;
private double pesoDepois;
Isso evita também a necessidade de chamar o método “calcula”, que provavelmente será chamado sempre.[/quote]
Concordo com a idéia do ViniGodoy, e somente para acrescentar essa forma também te previne para o problema do desenvolvedor esquecer de chamar o metodo “calculaXXX()” antes de chamar o getResultado()
Olá ViniGodoy,
Obrigado pela ajuda,
o motivo de não usar
interface é porque
eu tenho várias análises
e cada uma é independente
da outra, e além disso
cada uma tem o seu cálculo
específico.
[quote=ricardocomp]Olá ViniGodoy,
Obrigado pela ajuda,
o motivo de não usar
interface é porque
eu tenho várias análises
e cada uma é independente
da outra, e além disso
cada uma tem o seu cálculo
específico.
Obrigado msm.
[]'s.[/quote]
Mais um motivo para você usar interfaces. Interfaces são usadas para você definir um contrato que deve ser cumprido por quem a implementa. Classes abstratas são usadas quando, além de fornecer um contrato, você quer fornecer uma implementação. Como cada análise é independente, isso significa que você quer maior liberdade de implementação, que você pode obter com o uso de interface.
Jóia rmendes08?
Obrigado pela ajuda
Mas se eu fosse usar uma interface
toda classe que implementasse
a interface seria obrigada a implementar
a assinatura dos métodos feita pelo contrato
da interface.
Por exemplo:
Além da classe do Extrato Seco
eu tenho outras como por exemplo
Álcool Superior:
public class AlcoolSuperior {
public double calculaCoefCorrelacaoAlcSup(Absorvancia[] absorvancia){
...
}
public double calculaKmAlcoolSuperior(Absorvancia[] absorvancia){
...
}
public boolean isFlagRegressao() {
...
}
...
}
Se usasse uma interface eu seria obrigado a implementar
um calculaKmXXX() na classe do Extrato Seco e Km
é um cálculo feito por 3 análises e mesmo assim
o Km delas usa parâmetros diferentes.
Digamos que você tenha uma determinada implementação de certos métodos que é mais ou menos sempre igual, exceto em alguns casos, e, como foi recomendado, você não queira usar herança para aproveitar a implementação.
Você pode criar uma classe que é a “implementação default” desses métodos, e usa delegação (não herança) para poder implementar esses métodos em outras classes que têm de implementar essa interface.
Vou dar um exemplo. Digamos que você tenha a seguinte interface:
interface Valuable {
int getValue();
}
e você saiba que em 75% das vezes você só quer a seguinte implementação:
public int getValue() { return r.nextInt(); }
Em vez de fazer todo mundo herdar de uma classe que implementa Valuable, você faz o seguinte:
class Diamond implements Valuable {
private Valuable v = new ValuableImpl();
@Override
public int getValue () { return v.getValue(); }
}
onde ValuableImpl é a seguinte classe:
class ValuableImpl implements Valuable {
public int getValue() { return r.nextInt(); }
}
Eu sei que é tedioso fazer a delegação (porque você tem N implementações de métodos que só redirecionam para o método correspondente). Isso, infelizmente, é tedioso mesmo - a linguagem Scala (que roda na JVM) tem uma solução bem mais limpa para esse problema.
[quote=ricardocomp]Jóia rmendes08?
Obrigado pela ajuda
Mas se eu fosse usar uma interface
toda classe que implementasse
a interface seria obrigada a implementar
a assinatura dos métodos feita pelo contrato
da interface.
Por exemplo:
Além da classe do Extrato Seco
eu tenho outras como por exemplo
Álcool Superior:
public class AlcoolSuperior {
public double calculaCoefCorrelacaoAlcSup(Absorvancia[] absorvancia){
...
}
public double calculaKmAlcoolSuperior(Absorvancia[] absorvancia){
...
}
public boolean isFlagRegressao() {
...
}
...
}
Se usasse uma interface eu seria obrigado a implementar
um calculaKmXXX() na classe do Extrato Seco e Km
é um cálculo feito por 3 análises e mesmo assim
o Km delas usa parâmetros diferentes.
Obrigado pela ajuda rmendes08 e rlazoti.
[]'s.
[/quote]
Cara, não entendi sua justificativa para não usar interfaces. Qual a relação entre as classes Analise, ExtratoSeco e AlcoolSuperior ? Não entendi essa dependencia entre ExtratoSeco e AlcoolSuperior.
