Porque o método “foo()” da classe One não pode ser sobrecarregado na classe Two?
class One{
void foo(){}
}
class Two extends One{
int foo(){}
}Isso gera o seguinte erro de compilação:
6: foo() in Two cannot override foo() in One; attempting to use incompatible return type
found : int
required: void
int foo(){}
^
1 error
Obrigado!
Sobrecarga seria int foo(int x){return x}, por exemplo.
Pois é…
vc no caso não realizou uma sobrecarga, e sim tentou realizar uma sobreescrita de métodos, assim, como o mesmo requer o mesmo tipo de retorno e vc colocou retorno como int, gerou erro.
Olá TiagoTC o exemplo que vc colocou não é de sobrecarga mas sim de sobreposição…
e segundo as regras da linguagem java vc não pode trocar o tipo de retorno de um método na sobreposição no caso de tipos de primitivos…por isso o exemplo acima é inválido
um exemplo correto de sobrecarga seria:
class One{
void foo(int x){}
}
class Two extends One{
int foo(){}
}
ou…
class One{
void foo(){}
}
class Two extends One{
int foo(int x){}
} em sobreposição de métodos vc só pode trocar o tipo de retorno no caso de retornos covariantes
por exemplo:
class Animal{
Animal foo(){}
}
class Cachorro extends Animal{
//isso é válido porque Cachorro é um subtipo de Animal
Cachorro foo(){}
}
espero que tenha entendido retornos covariantes é quando vc cria um método em uma superclasse por exemplo com um tipo de retorno do tipo X e na subclasse vc pode sobrepor o método e trocar o tipo de retorno para um tipo Y desde que Y extends X
só lembrando que retornos covariantes não funciona para tipos primitivos por isto o seu código não compilou
Por que causa da “regra da lista de parametros”. O método fool() da classe One tem o tipo retorno “vazio” (void) e sem lista de paramtros. Na classe Two, embora tenha int como tipo de retorno, teria que ter a lista de parametros diferente.
Portanto
Para overriden o método tem que ser literalmente igual (tipo de retorno, nome do método e lista de parametros). Mas no overload, a assinatura tem que ser diferente.
E o que é assinatura diferente? É o nome no método e sua lista de parametros
Entendi. Eu pensei que somente de mudar o tipo de retorno, já podia ser considerado um “sobrecarregamento”. Agora, porque não é possível colocar “private” no método da classe Two do seguinte código?
class One{
void foo(){}
}
class Two extends One{
private void foo(){}
}Porque esse modificador private na classe Two não deixa a compilação ocorrer? No que isso interfere na classe One?
porq vc está deixando o modificador de acesso mais restrito
se vc fizesse ao contrário estaria correto
class One{
private void foo(){}
}
class Two extends One{
public void foo(){}
}
lembre - se no caso de sobreposição de métodos o método da subclasse deve ter o modificador de acesso menos restrito do que o da superclasse
[quote=vmsb11]porq vc está deixando o modificador de acesso mais restrito
se vc fizesse ao contrário estaria correto
class One{
private void foo(){}
}
class Two extends One{
public void foo(){}
}
lembre - se no caso de sobreposição de métodos o método da subclasse deve ter o modificador de acesso menos restrito do que o da superclasse [/quote]
Humm, entendi. Mas existe alguma explicação para essa regra, tipo, do porquê ela existe? Não vejo problema em sobrecarregar um método com um modificador de acesso mais específico…
por causa do polimorfismo…
se vc sobrepor um método de uma classe como private por exemplo na subclasse vc não poderia usar o polimorfismo porq ele não conseguiria encontrar o método privado por exemplo:
class Animal{
public void foo(){}
}
class Cachorro extends Animal{
private void foo() { }
}
class Teste {
public static void main(String[] args) {
Animal a = new Cachorro();
//chama o método foo da classe cachorro mas não funciona porq o método é privado e estou acessando ele fora da classe cachorro
a.foo();
}
}Entendi vmsb11. Muito obrigado! 
[quote=vmsb11]porq vc está deixando o modificador de acesso mais restrito
se vc fizesse ao contrário estaria correto
class One{
private void foo(){}
}
class Two extends One{
public void foo(){}
}
lembre - se no caso de sobreposição de métodos o método da subclasse deve ter o modificador de acesso menos restrito do que o da superclasse [/quote]
Isso não é uma sobreposição!
Métodos privados não são herdados, logo não podem ser redefinidos na classe filha. Para ser uma sobreposição, o método foo na classe One deveria estar marcado como protected ou sem modificador de acesso (default)
isso msm… esqueci de dizer que métodos privados não são herdados mas msm assim o exemplo que dei é válido,
e só lembrando se uma superclasse tem um método com um modificador de acesso X a subclasse deverá ter o método(no caso de sobreposição) com o msm modificador de acesso ou menos restrito…
a ordem de modificadores de acesso:
private -> default -> protected -> public mas como ja foi mencionado a subclasse não herda métodos privados…
abaixo está as regras para sobreposição e sobrecarga de métodos tirados do livro da katy sierra, está em inglês mas acho que vale a pena ler
Aproveitando o tópico, deixa eu perguntar outra coisa.
Aguém teria um resumo de todos os modificadores de acesso (public, private, protected, default) permitidos em cada parte de um programa (quero dizer, nas classes, nos métodos, nas interfaces, construtores…) Por exemplo, uma classe NUNCA pode ter o modificador de acesso private, mas um construtor pode! Eu queria uma lista resumida dessas coisas… mas não acho em lugar nenhum.
Obrigado!!! 
Procure pelo livro SCJP da Kathy Sierra, nele há um capítulo que explica bem sobre Override e Overload de métodos
vou fazer um pequeno resumo:
modificades de classes toplevel só podem ser public e default
modificades de enums toplevel só podem ser public e default
modificades de interfaces toplevel só podem ser public e default
classes que são declaradas dentro de outra classe(com exceção de classes internas anônimas) podem usar os 4 modificadores de acesso, e isso se aplica para enums que são criadas dentro de classes
métodos podem usar os 4 modificadores de acesso
só ressaltando que:
membros default só podem ser acessados dentro do msm pacote
membros private só podem ser acessados dentro da própria classe
membros protected podem ser acessados dentro de classes do msm pacote e de classes de pacotes diferentes(só que neste caso só através de herança)
membros public podem ser acessados de qualquer classe do mesmo pacote ou fora deste pacote.
o ideal seria vc praticar todos esses modificadores e dar olhada em algum livro pois oque eu escrevi está bem resumido.
