Where was it's epicenter?
Which is the only the information we had before.
And so what we might do now is create a feature or
a variable of type feature that points to an object of type PointFeature.
And that PointFeature says that it's associated with some location in a map,
and then we can add properties to that object.
And we get to decide what those properties are.
So every time we'd like to add some attribute or some property to this object,
to this collection of information about some location in our map,
what we can do is use the add property method that's supplied to us
by the data types that built into the library.
And this method takes in two parameters.
One is the a string that represents the title of the the title
of the property that we're about to set,
and then the second argument is the value of that property.
And so, we can see here that we've added properties for the title, for
the magnitude, for the date, and then for the year.
Now, once we have all of this information bunched into
a nice tidy object of type hoit feature,
what we can do is create a marker that uses that information and for example
we can feed into this marker all of the properties that we had bundled together.
And then add the marker to our map and so at this point, when we
run this in Eclipse, we won't see anything different from what we did before.
The end result of what we've just done is still just to add a marker
in the location of the epicenter of this Chilean earthquake from 1960.
But in the background, under the hood, there's actually a lot more that we could
access about that marker if we then wanted to style it in various ways.
And we'll see that in a minute.
So that's what we wanted to do if we had
just a single marker that had some rich data associated with it.
But maybe we want to think about not just the worst earthquake that was ever
recorded but maybe about, say, the top five.
And so we can look up some of the most significant earthquake events
that have happened in the world and say we wanted to add those into our map.
And so we want to translate this data
into objects that then we can manipulate in our map.
And so we can go ahead and do that in our code, and so
we could create feature objects for each one of these earthquakes.
And what we'd like to do now is instead of having to deal with each one of these
individually every time, and remember the names of all the variables that we've
associated with it, et cetera, we'd like to somehow group them together
into some data type that we can iterate over.
And lists are fantastic for that.
So what we might do is, we might declare a list that contains point features.
And it's going to point to a new array list that will contain point features.
And so, notice that in this declaration we're doing two things
that seem a little bit sophisticated.
One is that we're using that inter play between and
interface and a class that implements that interface.
And so notice the variable here is of type list.
Where as the object we created is of type array list.
Which is a data type that implemented that abstract data type of list.
And We have a support video coming up that will talk through some of those details.
And we'll also in a lot of detail about interfaces, and
abstract data types, next week.
So there's more coming to that,
but for now we want you to be comfortable using some of these constructs.
The other piece here that we'll go into more depth in the support video
is the fact that we're using generics.
So we're not just defining any old list, but we're also
telling Java What kind of objects are being stored in this iterable list.
We're saying that in particular each one of the elements
in this list is a point feature.
And the advantage of that then is that when we go through the list and
read off the objects one by one,
we'll know that what we're getting back is a point feature, and so
we'll be using all the methods that are associated with those point features.
So once we've declared and created this object,
now we can add elements to that list.
And so we can go ahead and add those five significant earthquakes to that list.
And the big advantage comes now when we want to represent those features
on in our map.
And so we want to create markers for each of those features.
Now because we put all of those earthquake features in a list.
In order to create the markers what we could do is iterate through that list and
we could say for each point feature in the list that we just created.
What we're going to do is add a new marker to a list of markers and that new
marker is going to be constructed from the information that
we get from the particular PointFeature that we got back from this list.
So every time we create a new marker, what we're doing is we're giving it
a particular location and particular collection of properties.
That are read off from one of these features that we created before.
So the effect of having this for each point feature in this list of
point features loop is that our markers list
will be populated with a single marker for each one of these significant earthquakes.
And then we can go ahead and add those markers to the map that's nice and
all but at that point, all of those markers look the same.
And so we have dots.
We have five different dots on our map.
But maybe we want to distinguish them, one from the other.
And so we could do it different for each loop and
look perhaps through our list of markers and customer the markers that we have.
And in the documentation for the folding maps library is a bit of a theme here.
If you want to look at that documentation we want to make sure that we understand
what functionality is available to us as we use these different data types.
One of the things that we can do to customize a marker is to change its color.
And so we can go ahead and check for each of the markers in our list.
Is it relatively recent, the event that is associated with this marker?
Or is its event older, more historic?
Vertical and so we could set some thresholds for ourselves.
For example, we could decide to style
the more recent IE after 2000 earthquakes to be yellow.
We could style the older ones, the more historical ones to be gray.
And there's lots of opportunities for customization here.
We'll invite you to do that as part of your project when you're working through
the real live data.
Now, as we're doing this,
you might have noticed that we had to type in all of the features for
each of these five earthquakes, that we wanted to represent on our map.
And that's cumbersome.
It's time consuming, and it's not scalable.
And it's also not very dynamic.
So If an earthquake happened today or tomorrow, and I want to
depict it in my map, I would need to sit down and write down all of its attributes.
And create a new object and feed it into And I feed it into the list and
do everything I've just done with every earthquake that came in.
And so what we'd like to think about is,
is there a way to dynamically update this list of feature and then the list of
markers that are associated with them that will be more scalable?
And one thing that we've provided for
you in the starter code that we hope you will find interesting is a parser.
And that parser is designed to read in data from the USGS and
what the USGS provides to anyone who is interest in this data is an RSS feed.
Which is basically bulletin that get's send out As
a text stream with updated information about earthquakes from around the world.
And so we can download the current version of this text file, and
you'll be doing that as part of your project.
And if we feed that through the parse feed library that we've provided for
you What we could do is translate all of the earthquakes that are depicted
in this text file to a list of features.
And so, we invite you to read through the ParseFeed class.
It will be a bit of an exercise in tracing Java code,
there's some complicated Constructs that we use there, and
as you work your way through the various courses and specialization
you may feel more comfortable with some of the methods that we use.
It's not required for you to understand all the details of the parser for
this project or for this course.
But that's part of the beauty of extending libraries as you're building code.
The focus of your developments time and energy is to design and build
the project that you want, and you can use any tool at your disposal for that.
And some of those tools may be written with techniques that you're
not comfortable with, or that you don't have mastery over but that's okay so
long as you know how to incorporate the end results of those techniques, and
the end results of those tools into the work that you're trying to do.
So in particular you'll notice that in the parse feed class we have a method
that will return to us a list of point features but then we can reiterate over,
just like we did before and create a list of markers but then we can add two r nap.
So At the end of all this what we create is this
beautiful map of the world where we've got the markers corresponding
to the most up-to-date information that we have from this RSS feed.
And then we can go through the list of markers that we create,
iterate over it, and customize the display of each of these markers
Based on whichever features you find most interesting and most important.
So good luck and I hope you enjoy that.
