Core: Using live data

Loading...

Из курса от партнера University of California San Diego

Object Oriented Programming in Java

2994 оценки

University of California San Diego

Object Oriented Programming in Java

2994 оценки

Курс 3 из 4 — Specialization Object Oriented Programming in Java

Welcome to our course on Object Oriented Programming in Java using data visualization. People come to this course with many different goals -- and we are really excited to work with all of you! Some of you want to be professional software developers, others want to improve your programming skills to implement that cool personal project that you’ve been thinking about, while others of you might not yet know why you’re here and are trying to figure out what this course is all about. This is an intermediate Java course. We recommend this course to learners who have previous experience in software development or a background in computer science. Our goal is that by the end of this course each and every one of you feels empowered to create a Java program that’s more advanced than any you have created in the past and that is personally interesting to you. In achieving this goal you will also learn the fundamentals of Object Oriented Programming, how to leverage the power of existing libraries, how to build graphical user interfaces, and how to use some core algorithms for searching and sorting data. And this course is project-based, so we’ll dive right into the project immediately! We are excited to be offering a unique course structure, designed to support learners of different backgrounds in succeeding at their own pace. The first module explains how this will work and if this course is right for you. We also recommend taking a few minutes to explore the course site. A good place to start is the navigation bar on the left. Click Course Content to see what material we’ll cover each week, as well preview the assignments you’ll need to complete to pass the course. Click Discussions to see forums where you can discuss the course material with fellow students taking the class. Be sure to introduce yourself to everyone in the Meet and Greet forum. This course should take about 6 weeks to complete. You can check out the recommended course schedule below to see a quick overview of the lessons and assignments you’ll complete each week. We’re excited you’re here learning with us. Let’s get started!

Из урока

Graphical output: Creating GUIs and Displaying Data

Now that you have the tools to write and trace object oriented code, let’s get back to developing the project! In this first (real) part of the project, you will create an interactive graphical map that will display geospatial data. This is a highly interactive week, so make sure you’ve got Eclipse loaded up! We encourage you to play around as you watch the videos. Some of the code that we use in the videos is in the demos package in the starter code you set up for this course. Open it up and experiment with it while you're watching the videos. We also encourage you to dive right into the programming project, even before watching the videos, if you want. The programming assignment instructions are in the last lesson of this week - you can watch a video walkthrough of the instructions and also read the step-by-step directions in the accompanying reading. There’s lots of room for creativity, too, so have fun!

Core: Why Processing?1:08

Support: Using Documentation7:08

In the Real World: Documentation3:24

Core: Setting up map visualization9:49

Core: Adding markers5:27

Core: Using live data11:18

Bonus: Visualizing life expectancy0:29

Bonus: Setting up the map4:48

Bonus: Representing data8:53

Bonus: Coloring markers11:42

Support: ArrayLists and Generics8:54

Познакомьтесь с преподавателями

Mia Minnes
Assistant Teaching Professor
Computer Science and Engineering
Leo Porter
Assistant Teaching Professor
Computer Science and Engineering
Christine Alvarado
Associate Teaching Professor
Computer Science and Engineering

So right now what we had was a map with a single gray dot on it to

indicate the epicenter of the Chile earthquake.

But really where our map comes to life is when we add

changing data based on the current earthquake data from around the world.

And what we'd like to do that then is think about handling and

displaying multiple markers and

having those markers be customized based on properties of the earthquakes.

And so, let's think about how we can get to that level.

So, in order to deal with more complicated data and more complicated displays on our

maps, it can be useful to separate two aspects of the data.

We can separate out the properties that we're thinking of defining

an earthquake from how we might want to represent visually those properties, or

that earthquake.

And unfolding maps actually let's us do that in a very clean way,

using different data types.

So, one of these data types we're more familiar with the marker interface,

that tells us about how to place dots on particular locations in the map.

And then how to style those dots, and so we've already talked about that.

But the new piece that we're going to add in now is the feature class.

And this feature class is a way of grouping together certain properties and

saying, this collection of information is somehow connected.

And I want to encapsulate it in a single object.

And so what we might do if we're thinking a little bit further about that important

Chilean earthquake is we might want to add properties about that earthquake,

like what was it's magnitude?

When did it occur?

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.

Ознакомьтесь с нашим каталогом

Присоединяйтесь бесплатно и получайте персонализированные рекомендации, обновления и предложения.

Coursera делает лучшее в мире образование доступным каждому, предлагая онлайн-курсы от ведущих университетов и организаций.

© Coursera Inc., 2018 Все права защищены.

Загрузить из App Store

Загрузить в Google Play