On 27 Dec 2005 05:06:52 -0800, "rajesh.shiggaon@gmail.com"
<rajesh.shiggaon@gmail.com> wrote, quoted or indirectly quoted someone
who said :

You can't unless you call it in class B or if you name it in A
something not overridden in B.

B.finalize should be calling A.finalize, so shouldn't be abstract.

In general you could get around this sort of situation by adding a
protected/package private method to B that calls A.finalize.

It's best to leave finalize methods as protected and throwing Throwable.
Or better still, don't use them.

Tom Hawtin

Why???

Omit your finalize() from class B. It isn't needed.

For your odd requirement, I might consider implementing the program
like this:

/***********************************************************
*      Name: C.java                                       *
***********************************************************/
class A {
  public void finalize() {
      finalizeImpl();
  }

  protected void finalizeImpl() {
      System.out.println("Inside the finaliaze method");
  }
}

abstract class B extends A {
  public abstract void finalize();
}

public class C extends B {
  public void finalize(){
      System.out.println("Inside the class B");
      super.finalizeImpl();
  }

  public static void main( String[] args ) {
      C myC = new C();
      myC.finalize();
  }
}

Hope it helps!

Regards,
Ranganath

So, by now, hopefully you have some idea of what the others have been
saying about why or how you could do this...  if not here's a little
something for you...

As you know your current approach won't work but we can get the same
effect legally by using a different abstract method, which the  base
class (B) calls....this is know as 'The Template Method'

class A {
   public void finalize(){
      System.out.println("Inside the finalize method");
   }

}

abstract class B extends A {
  public abstract void extraFinalizeStuff();

   public void finalize(){
      super.finalize();
      extraFinalizeStuff();
   }
}

class C extends B {

  public void extraFinalizeStuff(){
    System.out.println("Inside the class B");
  }

}

So this is basically saying that any class deriving from B must
implement (or itself be an abstract class) the 'extraFinalizeStuff()'.

Those derived classes don't need to override the base class's
'finalize()' method, as it will automatically call the
'extraFinalizeStuff()'.

Note however, this approach is only ever going to enforce that the
implementing derived classes implement the template method, it doesn't
help for further derived classes below that.

Aside from this, the notion of using inheritance, whilst appealing is
itself, its own worst enemy, because of issues like this and more.  If
we took the delegation approach to your problem, we would move the code
that lives in those finalize methods, into classes of their own and so
we wouldn't have to chain them together, they would behave just like
normal classes.

Andrew

Ask yourself why you want to do so. If you need to finalize(), then you
are dealing with some resource not (easily) accessible to the garbage
collector. Adding more finalization usually indicates these resources are
not well-encapsulated. Consider moving the resource handle into an own
class which deals with finalization, and let the gc do the rest.

Or, to state it differently:

protected final void finalize() throws Throwable { /* ... */
}

is about the only kind of finalizer there should be.