Arquivo Discussoes de Programacao e Tecnologia Alguém sabe dizer se é possível
saber se o método da super classe foi sobrescrito na subclasse?
(Sem ter criação de variáveis!)
Tenho um método na super que vai executar uma operação default caso
não tenha sido sobrescrito na sub.
Tendo em vista que mesmo quando for sobrescrito ele vai chamar o da super para finalizar
a operação. (por isso preciso saber se foi sobrescrito )
class A {
void foo(){
//faça algo
}
}
class B extends A{
void foo(){
//faça algo novo
super.foo();
}
}
Pra que você precisa saber da sobrescrita? Quando chamar o foo(), se ele tiver sido sobrescrito, ele faz a sua operação e depois chama o super.
class A { void foo(){ //faça algo } } class B extends A{ void foo(){ //faça algo novo super.foo(); } }Pra que você precisa saber da sobrescrita? Quando chamar o foo(), se ele tiver sido sobrescrito, ele faz a sua operação e depois chama o super.
É assim,
a sobrescrita vai montar dinamicamente as colunas de um grid (exemplo id, nome, descricao)
e o método da classe super não monta as colunas, mais eu gostaria
que montasse duas, caso o método não fosse sobrescrito na subclasse, por default (exemplo , id e descricao)
Alguém sabe dizer se é possível
saber se o método da super classe foi sobrescrito na subclasse?
(Sem ter criação de variáveis!)Tenho um método na super que vai executar uma operação default caso
não tenha sido sobrescrito na sub.
Tendo em vista que mesmo quando for sobrescrito ele vai chamar o da super para finalizar
a operação. (por isso preciso saber se foi sobrescrito )
Vc precisar disto denota problemas no seu design. A classe nunca sabe se foi ou não herdada. Isso é o objetivo. Se ele precisa saber, está errado.
O jeito de fazer é assim :
// na classe mae
public final void facaalgo(){
facaalgoEspecial();
}
protected void facaalgoEspecial(){
// implementação default
}
// na classe filha
protected void facaalgoEspecial(){
// implementação especial para o filho
}
Se o filho sobreescreve, a implementação dele irá ser xecutada. Senão sobreescrever a implementação padrão será usada. Não ha if. O mecanismo de herança já trata do problema.
kleberdamasco ,
Até é possível saber, em tempo de execução, se o método foi sobrescrito, com algumas ressalvas. Abaixo coloquei um exemplo, utilizando três classes:
package br;
public class ClassZ {
public static void main( String[] args ){
ClassA classA = new ClassA();
classA.method1();
System.out.println( "-----------------" );
ClassB classB = new ClassB();
classB.method1();
}
}
package br;
public class ClassB extends ClassA{
@Override
public void method1(){
super.method1();
}
}
package br;
public class ClassA {
public void method1(){
this.analisaChamador();
}
private void analisaChamador(){
try{
throw new Exception(); //Força o disparo de exception.
}
catch( Exception e ){
StackTraceElement elementChamador = e.getStackTrace()[2];
System.out.println( "Método Chamador: " + elementChamador );
try{
Class classChamador = Class.forName( elementChamador.getClassName() );
if( !ClassA.class.equals( classChamador ) ){
if( classChamador.isInstance( this ) && classChamador.getMethod( "method1" ) != null ){
System.out.println( "Método SOBRESCRITO. :)" );
}
else{
System.out.println( "O método chamador NÃO pertence a uma classe filha desta ou NÃO está sobrescrito. :(" );
}
}
else{
System.out.println( "Método chamador pertence a esta classe. :(" );
}
}
catch( Exception ex ){
ex.printStackTrace();
}
}
}
}
Realizei dois testes (ver classe ClassZ), abaixo descritos:
No 1º, a chamada ao método method1 foi realizada diretamente pela classe ClassZ, a qual não herda da ClassA.
No 2º, a chamada ao método method1 foi realizada através da classe ClassB, a qual herda da ClassA, e que sobrescreve o método.
Valeu ai rapaziada pelas respostas!
