Explore
For Enterprise
Join for Free
Log In

Browse
Search
For Enterprise
Log In
Join for Free

Relationships Between Classes

Loading...

Java Programming: Principles of Software Design

Duke University

4.6 (833 ratings) | 53K Students Enrolled

Course 4 of 5 in the Java Programming and Software Engineering Fundamentals Specialization

Solve real world problems with Java using multiple classes. Learn how to create programming solutions that scale using Java interfaces. Recognize that software engineering is more than writing code - it also involves logical thinking and design. By the end of this course you will have written a program that analyzes and sorts earthquake data, and developed a predictive text generator. After completing this course, you will be able to: 1. Use sorting appropriately in solving problems; 2. Develop classes that implement the Comparable interface; 3. Use timing data to analyze empirical performance; 4. Break problems into multiple classes, each with their own methods; 5. Determine if a class from the Java API can be used in solving a particular problem; 6. Implement programming solutions using multiple approaches and recognize tradeoffs; 7. Use object-oriented concepts including interfaces and abstract classes when developing programs; 8. Appropriately hide implementation decisions so they are not visible in public methods; and 9. Recognize the limitations of algorithms and Java programs in solving problems. 10. Recognize standard Java classes and idioms including exception-handling, static methods, java.net, and java.io packages.

Skills You'll Learn

Programming Principles, Interfaces, Software Design, Java Programming

Reviews

4.6 (833 ratings)

5 stars
622 ratings
4 stars
156 ratings
3 stars
34 ratings
2 stars
8 ratings
1 star
13 ratings

NS

Jun 16, 2016

Like all the modules of this Java specialization, the teachers are very good and the course reaches the objective of teaching the fundamentals of software design with an excellent didactic.

KK

Aug 16, 2019

amazing material - solid learning for Java\n\none struggle - discussion boards don't seem to be monitored by staff most of the time - expect to do most on your own without teacher input

From the lesson

Earthquakes: Programming and Interfaces

In this module, we will introduce a data set containing details about earthquakes around the world. You will learn how to pull this data into a program, search through the data, and filter the data based on desired criteria. By the end of this module, you will be able to (1) write programs that include multiple classes and ArrayLists of class types, (2) find the maximum value in an ArrayList, (3) use a Filter interface to search through data, (4) implement interfaces with method signatures, and (5) combine several filters together.

Introduction7:12

Relationships Between Classes4:47

Licensing and APIs3:08

Coding a Magnitude Filter10:32

Coding the Closest Quakes12:12

Taught By

Robert Duvall
Lecturer
Owen Astrachan
Professor of the Practice
Andrew D. Hilton
Associate Professor of the Practice
Susan H. Rodger
Professor of the Practice

Transcript

Hi in this lesson we're going to talk about a few concepts related to how classes are used together in object oriented programming in general, and specifically when using Java and the earthquake programs and classes you'll see. The QuakeEntry Class created in QuakeEntry.Java. Encapsulates the basic characteristics of one earthquake. Where the quake occurred, the quake's magnitude and depth, and a title for the quake. This makes QuakeEntry what's called a POJO, or Plain Old Java Object. This means a QuakeEntry object is not much more than the characteristics of the earthquake. Creating a QuakeEntry object requires providing all of these characteristics. For example, it doesn't make sense to talk about an earthquake without knowing where it occurred or how strong it is. It's not possible to creat a QuakeEntry object without supplying all the parameters of the constructor. Which makes this different than what some consider a Plain Old Java Object or POJO. As we'll see QuakeEntry objects are created when data for earthquakes is red and parched. Creating a QuakeEntry object requires supplying all the information for a quake. The latitude, the longitude, the magnitude, the tile and the depth. A QuakeEntry object represents the data for an earthquake that has occurred somewhere in the world. So it's immutable and doesn't change once constructed. Accessing the state of an QuakeEntry object is done using getter methods as you see here. Get location returns the location of a quake. Get depth returns the depth of the quake and so on. A QuakeEntry object also has a reasonable .toString method to help with printing information about an earthquake. An earthquake occurs at a specific location, and so we'll use a location class for that. Location classes have many uses outside of the QuakeEntry class we're studying here. Smartphones use locations. Web browsers use locations and many other applications do as well. We have a choice between creating a location class that's simple that we could use and study for this course or we could use an industrial strength class that would be tested and useful in other contexts. We've adopted the location class from the Android platform. This gives us the best of several options. We can be confident that the class is well tested and the licensing of the source code allows us to use and adapt the code as we need to. We'll see more about this later. Location objects are created from a latitude and a longitude. These specify one location on Earth. Typically these values might come from your phone which get data from GPS satellites or your web browser which can determine location based on your IP address. The Android location class has a dot distance to method to determine the distance between any two locations A and B. This will allow you to find earthquakes close to where you live. This makes the location class more than a Plain Old Java Object or POJO. It has state, the latitude, and the longitude, but it also has behavior, a method to determine the distance between locations. Classes in Java can have both Has-A, and Uses-A relationships. The earthquake partial class creates QuakeEntry objects when data is read and parsed. This BlueJ class diagram shows how the parser uses QuakeEntry objects by creating them. A QuakeEntry object also creates a location object as seen in the diagram. The QuakeEntry class creates a location object by passing the latitude and longitude to the location object. This creates a new location object using this data. The location object created is stored in instance field myLocation. When one class Has-A or contains another class, we call this a Has-A relationship. The location class implements comparable, we'll discuss this at another lesson. As you can see the BlueJ diagram, the earthquake client class also uses a location object. Locations are used to determine which earthquakes are closest to where you live, or to where I live. We'll see this in the coding demo. The location .distanceTo method helps in writing this code. A QuakeEntry object is also used by the EarthQuakeClient class. For example, this allows client programs to find all quakes of high magnitude using the getMagnitude method of the QuakeEntry class. Happy programming.

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.

© 2019 Coursera Inc. All rights reserved.

Get it on Google Play

Coursera
About
Leadership
Careers
Catalog
Certificates
MasterTrack™ Certificates
Degrees
For Enterprise
For Government
For Campus

Community
Learners
Partners
Developers
Beta Testers
Translators

Connect
Blog
Facebook
LinkedIn
Twitter
Instagram
YouTube
Tech Blog

More
Terms
Privacy
Help
Accessibility
Press
Contact
Directory
Affiliates