Bonus: Visualizing life expectancy

Loading...

From the course by University of California San Diego

Object Oriented Programming in Java

2995 ratings

University of California San Diego

Object Oriented Programming in Java

2995 ratings

Course 3 of 4 in the 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!

From the lesson

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

Meet the Instructors

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

[MUSIC]

In this part of the project you'll be customizing a map using dynamic data.

So in the next three videos what we'll be doing is stepping through an example that

has a similar objective.

So you can see how you might want to design your thinking for

the next part of the project and also see how we might do it in practice.

So by the end of this sequence of videos, you'll be able to

approach customizing maps, and you'll be reading in data files and

working with the data that you get from those files.

And then you'll organize that data using objects both from the unfolding libraries

and objects that you define yourself, and

we'll be thinking about organizing data using some abstract data types.

So let's start by setting up the problem,

and this example I just find really striking.

So what we'll be doing is annotating a map of the world, so

we'll look at all countries in the world and

we'll be thinking about data for average life expectancy at birth.

You can think about a person born on the other side of the world from you,

and as they start off their life journey,

how long might they expect to have on this world?

So there's data collected by the World Bank and you can read it in.

And what we've done is annotate this picture of the world,

this map of the world, so that the bright red spots are countries where

the average life expectancy at birth is somewhere around 45 years.

And the bright blue spots have average life expectancy around 85 to 90 years.

And so just in this visualization we see that the range of life

expectancies we find globally.

And this is pretty striking, and so by the end of the videos, you'll be able to do

similar visualizations with all sorts of data sets that are available online and

in other sources and that we'll also make available for you through this course.

So the life expectancy data that we might get, say from the World Bank,

for example, comes to us as a spreadsheet, comma separated values.

Lots and lots of rows in this file.

And we want to make sense of it,

we want to present it in a way that's easier to understand and organize.

So when we have a high level objective like drawing pictures or

visualizing data on a map, it's useful to break it down into manageable

chunks before we sit down to program a solution up.

And so for this particular problem, we can think of our project in three stages.

First, we might setup the map, configure the window and display the countries.

Then we might go to reading in the data, and looking at the data file that we have.

And finally we can convert that data into a visualization on the map.

So the videos will be separated into these three stages and

we'll wrap up this video by setting up our map.

So this is a good opportunity to think back to the beginning of your project.

And you've already played around with similar code where we declare a class, we

create a new class, that extends PApplet and uses the UnfoldingMaps library.

So in this class definition we are in a new file, the LifeExpectancy file.

And remember that the file name has to match the class name.

And what we're going to do is create a map and

then we have to define two methods, the two methods that will setup our applet and

then draw it continuously while the applet is running to update the view.

Okay, so let's start by setting up the map and

that first line of code is setting up the size of the canvas.

We've seen that in a few earlier videos so hopefully it's familiar at this point.

And then beyond that we're creating a new map.

So we're using the constructor for the UnfoldingMap, and we're creating a new

map object that we'll be manipulating and using throughout the project.

All right, this is slightly new and what we're doing here is using

one of the built-in methods in the UnfoldingMaps library.

And what this method does is allow

the user to interact with the map in some limited ways.

So by invoking MapUtils.createDefaultEventDispatcher,

which all seem like magic words at this point, but if you invoke this little

magic command, What that happens when we run our applet is that double-clicking

leads to zooming in in the map and we can do some panning around in the world.

Now, computer science is not magic and

we will make all of this clear in a future module.

We will talk about event handlers.

We'll talk about what's going on under the hood, but for

now in order to add some added interactivity, we use this line of code.

Okay, so we've set up the map a little bit,

we've created a map object and we've configured its size.

And now if we go ahead into that draw method, we can call the map's own

draw method, each UnfoldingMap comes with its own draw method, that will refresh

the screen based on the current objects and parameters associated with the map.

And so at this point what we have is that default canvas with the map of the globe.

And what we'll do in the next two videos is start bringing in our data and

shading the countries of the world based on the life expectancy data that we

talked about earlier.

Explore our Catalog

Join for free and get personalized recommendations, updates and offers.

Coursera provides universal access to the world’s best education, partnering with top universities and organizations to offer courses online.

© 2018 Coursera Inc. All rights reserved.

Download on the App Store

Get it on Google Play