Ola a todos,
Alguem ja tentou utilizar a clausula super() dentro de um metodo, depois
criar uma nova classe herdando a que implementou o metodo e chamar este
metodo a partir desta nova classe ? Por exemplo :
public class Obj {
public int toPersistent() {
//nenhum codigo aqui, usada apenas para não gerar erro de compilacao no
metodo toPersistent da classe Obj por causa do uso da clausula super()
return 0;
}
}
public class Resource extends Obj {
public int ID; //sem usar encapsulamento para facilitar o exemplo
public int toPersistent() {
//o codigo da rotina de persistencia é todo implementado aqui !!!
//a ideia é implementar toda a rotina de persistencia uma unica vez
//e utiliza-la para todas as classes filhas sem reimplementar novamente
para cada filho
//utilizando o mecanismo de reflexao para descobrir os campos da
//instancia do filho onde foi invocada e usando o super() para
//persistir a classe exatamente superior antes de persistir a si mesmo
//por causa da integridade referencia usada no RDBMS.
if (...) // Se o metodo esta sendo executado dentro de qualquer filho
int idSuper = super(); //persistente o pai antes de persistir a si
mesmo
}
// rotina de gravacao desta instancia aqui !!!
return idThis; //retorna o ID desta instancia dentro do DB usado na
gravacao do filho para efeito de integridade referencial
}
}
public class Person extends Resource {
public String Nome; //sem usar encapsulamento para facilitar o exemplo
}
public class Employ extends Person {
public String Depto;
}
...
Employ e = new Employ();
e.ID = 100;
e.Nome = "Billy Joy";
System.out.println("ID???:"+e.toPersistent());
...
Conclusao...
Segundo o conceito de heranca (se eu estiver errado por favor me
corrijam...), um metodo herdado deve se comportar como se ele estive sido
implementado fisicamente dentro da classe, sendo transparente para o
usuario os detalhes e a classe onde foi fisicamente implementado.
Li em algum lugar que a JVM trabalha com "ligamento dinamico", no caso de
polimorfismo e herança para determinar qual ou onde o metodo deve ser
chamado em runtime, porem neste caso isso não funcionou para super() pois
independente de onde se chame o metodo a clausula super assume como
referencia a classe onde foi fisicamente implementada, neste caso a
classe "Resource", desta forma não consegui fazer com que super() se
referencie a classe pai de onde esta sendo invocada.
Pelo que entendi o compilador faz uma ligacao fisica do filho com a classe
pai no caso da clausula super() (e no restante uma ligacao dinamica !?!?),
isso faz com que a resolucao da clausula super pela JVM tome como
referencia o metodo onde foi implementado e não de onde foi invocada para
determinar quem é o pai da classe onde o metodo esta sendo invocado !!!!
Será que isso é pra ser assim mesmo ou temos ai talvez uma falha de
conceito, ou talvez um bug do compilador...
Alguem poderia comentar o assunto ?
Alessandro.
------------------------------ LISTA SOUJAVA ----------------------------
http://www.soujava.org.br - Sociedade de Usuários Java da Sucesu-SP
dúvidas mais comuns: http://www.soujava.org.br/faq.htm
regras da lista: http://www.soujava.org.br/regras.htm
para sair da lista: envie email para [EMAIL PROTECTED]
-------------------------------------------------------------------------
