In this lesson we stop and put all that we’ve learned into action. We’ll complete another object modeling exercise together. But this time, we’ll make use of inheritance, polymorphism, and other new ideas that we recently learned. Welcome back!
But, as we frequently do, let’s warm up with another graded debugging challenge!
Define a public
class named Counter
with a single public
instance method named increment
.
increment
takes no parameters and returns an int
.
The first time it is called it should return 0
, the next 1
, the next 2
, and so on.
Each instance of Counter
should maintain its own private
counter.
Last time we did a game, and I said: I’m sorry we’re doing a game. This time we’re going to do something that may seem a bit like navel-gazing. And I’ll say: I’m sorry we’re doing something course-related. This is what I think about!
So let’s model office hours.
One way to begin object modeling is to think about what kind of entities we need to model and what kind of relationships they should have with each other. Let’s start there:
Next, let’s consider the kind of actions and methods that our objects need to support. That will help guide us as we add required instance variables.
Next, we’ll pick a pair of the methods on our Room
class to implement.
Finally, we’ll finish at least a preliminary implementation of our office hours model. And then discuss how you could extend and improve it!
Create a public class called Last8
.
You should expose two public methods:
add
: adds a value, does not return a valuelast
: returns an array containing the last 8 values that were added, in any order.You do not need a constructor, but you can add an empty one if you need. Until 8 values have been added you should return 0s in their place.
For example, here's how an instance of Last8
should work:
Do not create a huge array to save the values. Submissions that do will be marked incorrect.
Create a public class named ClosestPoint
, which we'll use to track the closest location to an initial location.
ClosestPoint
should provide a public constructor accepting a single Location
as its only parameter, which sets
the origin.
assert
that the initial Location
is not null
.
The Location
class stores latitude and longitude values as double
s, which you can retrieve using getLatitude
and getLongitude
.
ClosestPoint
provides two public methods.
add
accepts a new Location
and, if it is closer to the origin passed to the constructor than any other
location previously passed to add
, it updates the closest location accordingly.
add
should also assert
that the passed Location
is not null
.
getClosest
returns the closest Location
passed to add
, or null
if add
has not yet been called.
A few notes on how to approach this problem.
You should calculate distance between two locations in the usual way for points on a flat surface.
(We're assuming, for the sake of this problem, that the Earth is, in fact, flat.)
However, because floating point math is sensitive to ordering, you should take care in how you compare two distances.
With double
s, it is usually safer to not say first > second
and instead first - second > delta
, where
delta
is a small value.
For this problem, use a delta of 0.0001
.
Create a public class called Last4Ordered
.
You should expose two public methods:
add
: adds a value, does not return a valuelast
: returns an array containing the last 4 values that were added in the order they were added.You do not need a constructor, but you can add an empty one if you need. Until 4 values have been added you should return 0s in their place.
For example, here's how an instance of Last4Ordered
should work:
Do not create a huge array to save the values. Submissions that do will be marked incorrect.
This problem is harder than it looks! A suggestion is to handle the cases until the array is initially filled separately. Once four values have been added, you will need to shift values around before adding a new one.
Do not use a List
to solve this problem.
Need more practice? Head over to the practice page.