Support: Using Documentation

Loading...

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

Object Oriented Programming in Java

2992 оценки

University of California San Diego

Object Oriented Programming in Java

2992 оценки

Курс 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

[SOUND] In this support video, I'm gonna talk to you a little bit more about

documentation and how you'll be using it throughout this course and

particularly in the homework assignment,

in the programming assignment that you'll get started on at the end of this module.

So in the last lesson, I showed you this page for the processing documentation.

And it has a bunch of methods that you'll find really useful when

you're trying to draw shapes and change the colors of your GUI display.

So let me just highlight a few, it's a pretty big page.

The few that we looked at.

So we're here in this 2D Primitives.

We wanna look at ellipses, lines, points, rectangles, so on and so forth.

We've got the color methods over here.

You can change the background color, you can change the stroke color,

the fill color of shapes, so on and so forth.

And you can play with any of these methods if you want but

let me give you a couple more that you might find useful.

Particularly implementing the key of that map which is these typography

functions down here.

So these are methods that you can use to draw text on your GUI.

So in particular this method here text(), that's what's gonna create a little

box where you can put some text on the display.

And then down here are a bunch of methods that allow you to change the attributes

of that text.

And again, with any of these methods,

the best way to get to know how to use them is to click on them.

And it'll take you to a page that gives you a whole bunch of examples

on how to call that method and what visual

implications that will have when you pass different arguments into the method.

The other thing I want to talk about is the documentation for

the unfolding maps library.

So this is at this URL that you'll open up when you're

doing your programming assignment.

unfoldingmaps.org/javadoc/ and it gives you information about all of the classes

and methods that are built in to the unfolding maps library and this is

a library that you've downloaded as part of that starter code that you set up.

But it can be pretty overwhelming because it seems to have a lot going on here.

So, let me help you navigate.

What you see up here in this corner right here, this is all of the classes,

or sorry, all of the packages that are defined in the unfolding maps library.

And as you know, from looking at the Eclipse starter code, packages are just

little ways to organize your classes, so that they're a little bit more organized.

And this windows's only really useful if you know what package your looking in.

If you just know the name of the class, you don't necessarily want to look here.

But if, for example you know that you only care about the map providers,

which is this package right here, you could click on this and what it will do

is it will limit this display down here, which is where you see all the classes.

So if I click providers up here then what I see down here are only the classes

that are part of that package.

And that can be useful because this can give you all the different possibilities

for what map providers you can use.

So here's the Google map provider,

here's a whole bunch of different Google map providers.

There's a bunch of different other, there's some Microsoft map providers,

there's an open map surfer provider.

So there's a lot of different map providers that you can

play around with and perhaps you already played around with in that first module.

But if you don't know what package you're looking in,

then you can just click here to All Classes, and

this will give you a list of all the classes that are provided by this library.

All right, so let me go to some classes in particular that you'll find useful for

this part of the project.

The first one is down here.

It's called SimplePointMarker.

This is the class that you're gonna be implementing.

You're gonna be creating instances of this class to create those markers on your map.

So you can click on it, and what you're gonna see on the right hand

side is all of the different methods and fields that this class has.

So you can see that it has a few different constructors and

we recommend using this constructor here that takes a location.

That will just create a simple point marker at a given location.

And if you want a little more information about this constructor you can

click on it.

It gives you a slightly expanded view of the documentation so

you can learn more about it that way.

And then there's a whole bunch of different methods that you

can use that are already implemented here.

Now just a caution against this draw method.

This draw method, you should not call explicitly.

This is called automatically for you, so do not call the draw method explicitly.

We're gonna learn more about that in the next module, but for

now just know, don't call draw on the simple point marker.

So then that might raise the question of how are you going to draw the simple

point markers?

Well, it all goes back to the unfolding map.

So here's the other class that you'll want to rely on this Java documentation for,

which is the sort of main class that your adding everything to to visualize the map.

And so this unfolding map class you can see we've already

looked a little bit at the various constructors that is has.

But you can see that it has a whole bunch of different constructors.

So you can play around with constructing these unfolding

map objects using different parameters as you like.

And then, you can see that it has a bunch of methods.

It has a lot of methods.

And in particular, for this assignment,

some of the methods that you're going to find useful are things like addMarkers.

For example, this method here takes a list of markers and adds them to the map.

And once those markers are added to the map, you'll see them appear.

This is, once they get added to the map that's what causes Java to automatically

call the draw methods in the markers, and displays those markers for you.

So those are just a few useful classes and

methods that you'll want to use on your programming assignment for this module.

So in addition to the documentation for processing and

for unfolding maps, Java itself actually provides documentation for

all of its libraries and classes and all the methods on those classes.

And you can find that at this URL here and

you can do a Google search for Java documentation.

One thing to note is that if you're working in Java version 7, you'll wanna

change that 8 to a 7 so that you match the version of Java that you're working with.

But what you can see basically here is every single class that Java implements.

And this can be really useful when you're working with a class that you don't really

know that well or that you've forgotten a little bit about.

So we encourage you to also use the standard Java documentation as well.

In general it's really to your benefit to start to get comfortable

playing around with this documentation and using this documentation.

Because in the real world, and even in this class, we're not gonna tell

you every single thing you need to know in order to use some library code.

Using library code is extremely common.

And there's no instructor sitting there, telling you, oh,

you should use this class and you should use this method.

It's up to you to read the documentation for that library, and

hopefully it's good documentation,

so that you can figure out how to use those classes and those methods yourself.

This will also drive home the importance of documenting your own code.

When you start writing code that you will provide to others to use,

all they're gonna have is this documentation to go by, so

it a really good idea to make it as complete and as useful as possible.

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

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

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

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

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

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