继承和方法

Question

I'm having a problem with the constructors of classes and sub-classes(that extend the first class)

This is the basic class's constructor:

    public Airplane(int x, int y, int width)
    {
        this.x = x;
        this.y = y;
        this.width = width;
        createSeats();
    }

And here is another class's constructor that extends the basic class

public Boeing(int x, int y, int width)
{
    super(x,y,width);
    createSeats();
}

The problem is that createSeats() is another method in both classes, but Boeing has to override the main one. How can I make it so that this will work without taking the createSeats() method out?

Answer 1

If you know you want all subclasses of Airplane to call createSeats() on construction then you can leave the call in the Airplane constructor and remove from Boeing .

If you only want particular subclasses, eg Boeing to call createSeats() on construction then you can leave the call in the Boeing constructor and remove from Airplane .

You don't need the invocations in both constructors, leaving them there will result in createSeats() being called twice for each Boeing you initialise.

Answer 2

The call to the super constructor already includes the call to the createSeats() method, so you don't have to reinclude it in the Boeing constructor.

If you only want to change the behavior of creating seats, just override that method.

class Airplane {
  public Airplane(int x, int y, int width)
  {
    this.x = x;
    this.y = y;
    this.width = width;
    createSeats();
  }

  void createSeats() { /* create them */ }
}
class Boeing {
  public Boeing(int x, int y, int width)
  {
    super(x,y,width); // same steps as super class
  }

  @Override
  void createSeats()
  {
    // do something else entirely
    // possibly call super.createSeats()
  }
}

Answer 3

Frequently a default implementation of a method is provided in a super class, which allows you to customize the behavior in a subclass by overriding the method in a subclass. Eg Does an Airplane know how to create seats on a Boeing ? Probably not, therefore you would override the createSeats () in your subclass to provide the specific implementation that works for you particular type of Airplane .

The fact that the createSeats () method is called from inside your super class' constructor guarantees that the method in question will always be called on construction of the object. This is a common design pattern. It's called template method. Basically you have a method that encapsulates the execution of a number of methods in a certain order to produce an outcome. In your case there's one method namely createSeats ().

Answer 4

I agree with @milkplusvellocet's answer, however you also said "The problem is that createSeats() is another method in both classes, but Boeing has to override the main one." If you ever need to call a superclass's method instead of your own, you can always call super.createSeats() . That way you can always differentiate between methods in the superclass and your own methods.

However, that said, that's almost always used in the method you're overriding. For example,

@Override
public void createSeats() {
  doSomethingSpecial();
  super.createSeats();
}

Answer 5

@Override

before the method you want to override should do the job