是否可以在Java中链接重写的方法

Question

Let's say that I have an abstract class:

abstract class DBTable {

    abstract boolean append();

}

And that I also have a child class that inherits from DBTable:

// Client objects are rows of a database table
class Client extends DBTable {

    @Override
    boolean append() {

    }
}

Finally, let's say that I have a subclass of Client which I have used to represent the denormalized form of a Client object (I feel that this is ok. It's all in the same package and a Client.Expand -is a- Client).

What I would like to do is override the append() method in Client.Expand, and have it chain up to the append() method in Client before coming back to doing work that is appropriate only for the subclass. Something like this...

    // Expand is a member class of Client
    static class Expand extends Client {

        @Override
        boolean append() {
            super.append();
            :
            :
        }
    }

Does Java allow this? I am getting errors from the IDE when I try to override a method that is already overridden in the parent class. It seems like I should be able to override an overridden method to provide for additional implementation needed by the child class, but maybe Java isn't built for this kind of inheritance?

Answer 1

There are several issues with your example:

1. When you declare a member of a class as static, this member is associated with the Class. It cannot be used with and instance of that class. For example, when you have a code in Expand's append method such as - super .append() - that "super" refers to an instance, not "class". Therefore it contradicts the static definition. As is suggested in the comments, you need to remove static from class declaration.

2. A child class, should not be an inner class, this is not a good design, even if it is allowed. Because, if you think about it semantically, a subclass is not a member of the super class (parent child words is misleading in this case, superclass and subclass are better) . Superclass should not know about classes that may extend it, it should be self-contained. Therefore, it is better to move subclass to a separate class.

3. Your design has some other issues as well: First of all, naming is not descriptive of the subject. If client represents a row, then Row, or TableRow, ... is perhaps a better name, and ExpendedRow for the next class.

But, more importantly, a row extending a table is not a good idea. A better approach might be to have a Row class and Table class composing Row. Something like this:

// Client objects are rows of a database table
class Row {

    @Override
    boolean append() {

    }
}

class Expanded extends Row{

        @Override
        boolean append() {
            super.append();
            :
            :
        }
    }
class DBTable {

    Row row;

}

Answer 2

I've found the problem. It's embarrassing. I'll answer my own question a bit circuitously as part of my own defense.

I like to design my classes so that a class subserves a theme. All the functionality that is related to that theme, I like to try and place into the same class. This works especially well for database data model classes, because the structure of the classes can often be repeated for other database model classes.

What do I mean exactly?

Well, here is the "structure" of my Client class. As you can see, it contains several member classes:

+----------------------------+
|  CLIENT                    |
+---+------------------------+
    |  static EXPAND         |
    +------------------------+
    |  static GHOST          |
    +------------------------+
    |  static BUILDER        |
    +------------------------+
    |  static INQUISITOR     |
    +------------------------+
    |  static QUERYBUILDER   |
    +------------------------+
    |  static JDBCFactory    |
    +------------------------+

I like this design a lot. It means that the class that builds Client objects for me can be in the same file as the Client class and I can invoke it with the semi-mnemonic "new Client.Builder()" or that I can create an object that builds SQL queries for Client objects with "new Client.QueryBuilder()". The class whose object becomes the factory for making Client objects from JDBC resultsets can be instantiated with "new Client.JDBCFactory" etc. etc. I like this a lot.

The downside ... is that I have a lot of braces.

And ... if I'm not careful, I can type something that ends up in the wrong context. In this case, where I was typing the definition for the append() method that I -wanted- to be in the EXPAND member class ... was actually just outside the brace and I was typing it into the context for CLIENT.

Well, Client already had an append() method and so the IDE was complaining to me that I was trying to override a method in the very same class that already had an append() method.

Yes, Java does fully support override chaining. There's nothing wrong with my IDE or JVM ... just with me. Thanks again to @Robe and others for their input.