Sharing Fields — Extending Classes

Student: When do I use inheritance?

Prof: There are a few different cases people talk about. One I think is important is sharing fields across classes.

Student: Sharing fields?

Prof: Let’s think about representing locations on a service like Google Maps. They might want to have a bunch of different classes for them, and an interface that ties them together. A heads up, we’re getting into some longer examples:

interface Place {
  String pinLabel();
  boolean onScreen(double south, double north, double west, double east);
}
class Restaurant implements Place {
  String name;
  double lat;
  double lng;
  double stars;
  Restaurant(String name, double lat, double lng, double stars) {
    this.name = name;
    this.lat = lat;
    this.lng = lng;
    this.stars = stars;
  }
  public String pinLabel() { return name + " (" + stars + " stars)"; }
  public boolean onScreen(double south, double north, double west, double east) {
    return lat >= south && lat <= north && lng >= west && lng <= east;
  }
}
class Park implements Place {
  String name;
  double lat;
  double lng;
  int acres;
  Park(String name, double lat, double lng, int acres) {
    this.name = name;
    this.lat = lat;
    this.lng = lng;
    this.acres = acres;
  }
  public String pinLabel() { return name + " (" + acres + " acres)"; }
  public boolean onScreen(double south, double north, double west, double east) {
    return lat >= south && lat <= north && lng >= west && lng <= east;
  }
}
class BusStop implements Place {
  int route;
  double lat;
  double lng;
  BusStop(int route, double lat, double lng) {
    this.route = route;
    this.lat = lat;
    this.lng = lng;
  }
  public String pinLabel() { return "Bus " + route; }
  public boolean onScreen(double south, double north, double west, double east) {
    return lat >= south && lat <= north && lng >= west && lng <= east;
  }
}
void main() {
  Place[] places = {
    new Restaurant("Taco Shop", 32.8795, -117.2359, 4.5),
    new Park("Balboa Park", 32.7341, -117.1446, 1200),
    new BusStop(30, 32.8790, -117.2368),
  };
  double south = 32.86;
  double north = 32.90;
  double west = -117.25;
  double east = -117.22;
  for (Place p : places) {
    if (p.onScreen(south, north, west, east)) {
      System.out.println(p.pinLabel());
    }
  }
}

Student: Wow you weren’t kidding that it’s longer.

Prof: Well, we’re talking about some more substantial design questions, so our programs do need to grow a bit! What do you notice and wonder?

Student: Well, I notice that each of these classes implements Place – there is no inheritance yet, because I don’t see extends.

Prof: Good, good. Other things?

Student: I wonder what a Pin is.

Prof: Oh good question. That’s a word for a point on a virtual map. So like a little icon or shape that shows up. The example is meant to capture different kinds of places and the information they might show. For example, the restaurant has a star rating but the bus stop just names its bus route.

Student: I see. And I notice that classes are being used instead of records.

Prof: Right, extends only works with classes, and we’ll see how it does help us a bit here. There is something shared across all the classes: do you see it?

Student: Hmmm… I guess lat and lng are shared across all of them.

Prof: Right. And with what we have, can we do anything to avoid having all those copies of lat and lng?

Student: Can we put lat and lng in one class, and then extend it from all of these?

Prof: That’s right! So the base class might be like this, though we’d have one problem:

class Location implements Place {
  double lat;
  double lng;
  Location(double lat, double lng) { this.lat = lat; this.lng = lng; }
  public boolean onScreen(double south, double north, double west, double east) {
    return lat >= south && lat <= north && lng >= west && lng <= east;
  }
}
// Then BusStop, Restaurant, etc can extend Location

Student: It says it implements Place, but has no pinLabel?

Prof: Yup. So we have to fill in some pinLabel if we want this to compile.

Student: What should it return?

Prof: It’s hard to say. At some point I’ll show you how to avoid having to choose, for now I’ll just fill something in:

class Location implements Place {
  // ...
  public String pinLabel() { return "Unknown Location"; }
}

Student: OK, so then what do the other classes look like?

Prof: Well, they gain extends and lose their lat/lng fields. But we have to decide what to do in the constructor. There is a special keyword, super(...) that we’ll need to use. In a constructor it calls the parent class constructor with the given arguments. It lets us re-use the constructor from the class we inherited.

interface Place { … }
class Location implements Place {
  double lat;
  double lng;
  Location(double lat, double lng) {
    this.lat = lat;
    this.lng = lng;
  }
  public String pinLabel() { return "Unknown Location"; }
  public boolean onScreen(double south, double north, double west, double east) {
    return lat >= south && lat <= north && lng >= west && lng <= east;
  }
}
class Restaurant extends Location {
  String name;
  double stars;
  Restaurant(String name, double lat, double lng, double stars) {
    super(lat, lng);
    this.name = name;
    this.stars = stars;
  }
  @Override
  public String pinLabel() { return name + " (" + stars + " stars)"; }
}
class Park extends Location {
  String name;
  int acres;
  Park(String name, double lat, double lng, int acres) {
    super(lat, lng);
    this.name = name;
    this.acres = acres;
  }
  @Override
  public String pinLabel() { return name + " (" + acres + " acres)"; }
}
class BusStop extends Location {
  int route;
  BusStop(int route, double lat, double lng) {
    super(lat, lng);
    this.route = route;
  }
  @Override
  public String pinLabel() { return "Bus " + route; }
}
void main() { … }

Prof: So we’ve moved the idea of a location out of all these places, and made that be the job of Location, which can also have the correct implementation of onScreen shared by all the subclasses. Now each of the subclasses is solely responsible for the implementation of pinLabel.

Student: Interesting!

Practice

Here is a social media feed, already refactored so Message holds the message field that every post shares. TextPost and Repost are done. Fill in VideoPost the same way.

interface Post {
String preview();
boolean mentions(String word);
}
class Message implements Post {
String message;
Message(String message) {
this.message = message;
}
public String preview() { return message; }
public boolean mentions(String word) { return message.contains(word); }
}
class TextPost extends Message {
boolean edited;
TextPost(String message, boolean edited) {
super(message);
this.edited = edited;
}
@Override
public String preview() {
if (edited) { return message + " (edited)"; }
return message;
}
}
class Repost extends Message {
String from;
Repost(String message, String from) {
super(message);
this.from = from;
}
@Override
public String preview() { return "Reposted from " + from + ": " + message; }
}
class VideoPost {
int seconds;
VideoPost(String message, int seconds) {

this.seconds = seconds;
}
@Override
public String preview() { return message + " [video, " + seconds + "s]"; }
}

Post[] feed = {
new TextPost("Exam moved to Friday", true),
new Repost("Free pizza in the CSE lobby", "tritons"),
new VideoPost("My cat learns Java", 42),
};
String third = feed[2].preview();
boolean aboutCats = feed[2].mentions("cat");