Re: Using "abstract" on a class with no abstract method

From:

Eric Sosman <esosman@ieee-dot-org.invalid>

Newsgroups:

comp.lang.java.programmer

Date:

Sat, 15 Aug 2009 17:16:20 -0400

Message-ID:

<h678ke$7ss$1@news.eternal-september.org>

Stefan Ram wrote:

  I have a class that is intended for subclassing,
  not for instantiation.

  So I thought, I could tag it with ?abstract?,
  even though it does not have any abstract method.

  Is this a good idea? Can human readers understand
  this application of ?abstract??

  Here is the concrete example:

abstract class MainCommand
extends de.dclj.ram.DefaultDirectedMessage
{ public MainCommand( final int direction ){ super( direction ); }
  @java.lang.Override public java.lang.String description(){ return "MainCommand"; }}

class QuitMainCommand extends MainCommand
{ public QuitMainCommand( final int direction ){ super( direction ); }}

  ?abstract? is foremost a kind of comment, intended
  for human readers of the source code, here.

     You can do it, but why? If the MainCommand class has no
abstract methods but only "concrete" methods, it appears
that a MainCommand object has all the code required to
stand on its own, to be a full-fledged object regardless
of subclasses. If it can operate on its own, fulfilling its
role in the program/framework/whatever, why make it abstract?

     If MainCommand can't really stand on its own because it
has a method that is fully implemented but "deficient" in
some way (the idea being that subclasses provide the missing
bits and then call super.method() from overriding methods),
maybe the situation would be made clearer with a few name
changes, and possibly marking the deficient method as protected.
That is, instead of

    /* abstract */ class Super {
        /** You probably want to override me */
        void method() {
            // incomplete implementation
        }
    }

    class Sub extends Super {
        @Override // Yeah, I guess I probably do
        void method() {
            // pre-stuff
            super.method();
            // post-stuff
        }
    }

you'd have

    abstract class Super {
        /** Possibly useful in implementing method() */
        /* protected */ void methodGuts() {
            // incomplete implementation
        }
        /** You <b>must</b> override me */
        abstract void method();
    }

    class Sub extends Super {
        @Override // Got no choice, do I?
        void method() {
            // pre-stuff
            methodGuts(); // Wow, that's convenient!
            // post-stuff
        }
    }

     Opinions may (i.e., "will") vary, but for me the latter
more clearly expresses the "Should be overridden" message.

     Hmmm: Here's a thought experiment. Suppose we go with
the "abstracted concrete class" and demand that it be
subclassed. Would this subclass be acceptable?

    class ThoughtExperiment extends Super {
        @Override
        void method() {
            super.method(); // That's all, folks!
        }
    }

If it's acceptable, why not just use Super directly? If it's
not acceptable, why not -- and can you find a way to express
the "why not" in Java?

--
Eric Sosman
esosman@ieee-dot-org.invalid