Eu entendi o q vc quis dizer getAdicted.
Mas o q tem d diferente nesse código, q é a dúvida do lucas_guj, e é algo novo pra mim, é q há uma mistura de métodos sobrepostos e sobrecarregados ao msm tempo.
Como eu disse, e o próprio lucas_guj pode verificar com testes, existe akela regra dos métodos sobrecarregados, q o q determina qual método será chamado é o tipo da variável d referência e não o tipo do objeto. Até ai td bem, nada d novo pra mim. Só que…
na classe pai tem o método:
e na classe filha tem os métodos:
fazer (Comida c)
fazer (Sanduiche s)
Quando vc faz usa essas classes da seguinte maneira, o q acontece?
Panela p = new Frigideira();
Comida s = new Sanduiche("bauru");
p.fazer(s);
Primeiro, o polimorfismo. Ou seja, mesmo o método sendo chamado por uma variável d referência do tipo pai, quem decide qual método será executado é a JVM, e esta verá q o tipo do objeto é d uma classe filha, portanto procurará na classe filha pelo método. Acontece q na classe filha existem dois métodos sobrecarregados, sendo q um método recebe como argumento um tipo genérico e o outro um tipo específico. Sendo assim, a lógica é aplicar a lei da sobrecarga (chamar o método do tipo da variável d referência e não do tipo do objeto). Mas será q é realmente isso o q acontece? O código acima executa o método da classe filha:
Bom, até ai a regra da sobrecarga e o polimorfismo funcionaram dentro da lógica esperada. Mas e se nós modificarmos o código da seguinte maneira:
Panela p = new Frigideira();
Sanduiche s = new Sanduiche("bauru");
p.fazer(s);
Agora a variável de referência passada como parâmetro é do tipo específico. Então a lógica seria executar o método da classe filha q recebe como argumento o tipo específico, certo? Errado!!! O método executado será o método da classe filha…
Isso sim é novo pra mim. A regra da sobrecarga não se aplica no polimorfismo. Se o método da classe pai tem como parâmetro um tipo Comida, a JVM não se importa se existem outros métodos sobrecarregados na classe filha q tem como parâmetro um tipo específico d Comida. A única coisa q a JVM se preocupa, quando realiza o polimorfismo, é se na classe filha existe um método fazer q tem como parâmetro um tipo Comida.
É por isso q quando o lucas_guj acrescentou o método:
na classe pai, é executado o método fazer da classe filha q tem como parâmetro um tipo Sanduiche. Se esse método não existir na classe filha, é executado o método da classe pai. Não sei se ficou claro, então vou modificar um pouco a classe Panela e a classe Teste:
Panela:
class Panela
{
public void fazer (Comida c)
{ System.out.println("Estou fazendo "+ c.getNome()); }
public void fazer (Sanduiche s)
{ System.out.println("Estou toooooostando "+ s.getNome()); }
}
Teste:
public class Teste
{
public static void main(String a[])
{
Panela q = new Frigideira();
Comida s = new Sanduiche("bauru");
Sanduiche x = new Sanduiche("x-tudo");
q.fazer(s);
q.fazer(x);
}
}
Nesse caso, a saída é:
Estou fritando bauru
Estou tostando x-tudo
Acontece o seguinte; como existem dois métodos sobrecarregados na classe pai, primeiro é aplicada a regra da sobrecarga para escolher um dos métodos. Se a variável de referência passada como argumento for do tipo Comida, é escolhido o método q tem como parâmetro o tipo Comida, se a variável de referência for do tipo Sanduiche, é escolhido o método q tem como parâmetro o tipo Sanduiche; como a variável q chama o método fazer faz referência a uma Frigideira, a JVM procura na classe Frigideira pelo método fazer q tenha EXATAMENTE o msm parâmetro do método escolhido na classe pai.
Se eu tiver falado alguma besteira podem me corrigir sem problemas. Espero ter ajudado.
