Explore
For Enterprise
Join for Free
Log In

Explorar
Buscar
For Enterprise
Inicia Sesión
Únete de forma gratuita

Core: Comparable Interface, Revisited

Loading...

Object Oriented Programming in Java

Universidad de California en San Diego

4.7 (3,590 calificaciones) | 170K estudiantes inscritos

Curso 3 de 4 en Object Oriented Programming in Java Programa Especializado

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!

Destrezas que aprenderás

Logic Programming, Java Programming, Object-Oriented Programming (OOP), Sorting Algorithm

Revisiones

4.7 (3,590 calificaciones)

5 stars
2,748 ratings
4 stars
695 ratings
3 stars
97 ratings
2 stars
27 ratings
1 star
23 ratings

KP

Feb 21, 2016

Enroll this course if you intend to become a programmer and need fundamental knowledge in Object Oriented Programming. Here you can study the subject and apply new things in a real curious project.

AS

May 31, 2017

One of the best course I have done on coursera. Everything is awesome about the course final project helped to extensively test my skill. This course is for learner with basic knowledge in java.

De la lección

Searching and Sorting: From Code to Algorithms

You've come a long way in this course, and you've got a great project to show for it. In this last module we'll shift gears a bit to talk about some very exciting and fundamental algorithms for finding and sorting data in an array. Searching and sorting algorithms are not only fundamental to computer science, but also ideal for beginning to explore issues of algorithm efficiency. We will only begin to touch on issues of algorithm efficiency here. We will say much more about it in the next course in this specialization, so we hope you will continue with us. We'll also apply sorting to your project, and you'll wrap things up by finishing your project with an extension of your own choosing.

Core: Introduction to Sorting7:39

Core: Selection Sort Algorithm3:51

Core: Selection Sort Implementation7:00

Core: Selection Sort Analysis5:13

Concept Challenge: Selection Sort4:59

Core: Mystery Sort13:20

Core: Java's Built-In Sort4:18

Core: Comparable Interface, Revisited7:58

Concept Challenge: Which Sort?3:16

Impartido por:

Mia Minnes
Assistant Teaching Professor
Leo Porter
Associate Teaching Professor
Christine Alvarado
Associate Teaching Professor

Transcripción

[MUSIC] In the previous video, we started talking about how to use the built-in sort that's available to us in Java. What I'd like to do now is to think about how to generalize that technique for more complicated objects. So by the end of this video, you will be able to define and use the Comparable interface in Java. So that we can have access to that built-in sort method. So if you remember last time, what we talked about is how to use collections.sort and then feed in a list of integers, and somehow magically get the list returned to us as a sorted list. Now, what we did in, or what we observed happens when we used this method is that we're using the Built in Merge Sort. And the beauty of that was that we didn't have to implement merge sort ourselves. The issue, though, is that the list that we gave it was an integer list, so all the values are numbers. But sometimes the objects that we want to sort, the data that we want to organize isn't just numbers. Maybe it's more complicated objects, and so what we'd like to do now is think about using this built in functionality but for collections of non integers. And so for example, we might want to sort airports. So remember back to the beginning of the module and the motivating example that we've been talking about. We have an array of airports and each of those, each of the array elements are references to airport objects. And what we'd like to do is sort this array based on the city of the airport. Okay? So if we try to just go ahead and, in our airport class, define a method within the main method that just says, let's sort our airports. So we have an airports list and we're gonna go ahead and sort it, then we can hope for the best and try to compile this. But unfortunately, we're gonna get a big old error message. And the reason for that error message is that airports are kind of hard to sort. We don't know how to compare two airports. So this is where the comparable interface comes in. And the comparable interface says, I will be able to give you access to merge sort and all of these other built in functionalities like sorting in Java, if you only tell me how to compare two object instances of your class. And so, for example, if we think about the object that has the city Montreal, and Canada, with a particular airport code, and the airport object that we have that's initialized to the airport in Lagos, then we might want to compare these two. And say, M comes after L in the alphabet, and so when we're thinking about the city names than the object that corresponds to the airport in Montreal should come after the object that corresponds to the airport in Lagos. On the other hand, we might want to organize our data based on country names, rather than city names. And so then, we might focus in on a different field. And look at the instance variable for country. And in that case we see that Canada, starting with a C, comes earlier in the alphabet than Nigeria, starting with an N. And so we'd want our objects to be organized a little bit differently. All right, so how do we do that, and how do we tell Java this order? Well, if our class implements the comparable interface. And we say that by adding that keyword to the class definition. Then our objects in that class will be able to be compared to one another. Now notice that special word that's after comparable. We've got the angle brackets and Airport. And that's saying that we're specifying what kind of objects we're going to know how to compare, and this is using generics. Okay, so if we've told Java, we promised that we're going to implement what's needed for a comparable class. What that's saying is that we have to fulfill the promise of the interface. And the interface comparable says, you must implement a compareTo method. And the compareTo method has to be called by an object in that class. And it's going to tell us how to compare that calling object to an input other object. Okay. So let's think about how we might do that. And think about what functionality we want. So we're going to return an integer, and that integer should demonstrate the relationship between the calling object and the other object. So if the calling object is supposed to be smaller than the other object, then the integer that we return is negative. If the smaller object, if the calling object is supposed to be sort of the same size as the other object, then we should return zero. And if the calling object is bigger than the other object, then we're going to return a positive number. And so what you might think about is the comparison method is something like doing subtraction, subtracting the calling object minus other object. That's sort of the reference that we have for why these integers are returned the way they are. Okay, so what we'd like to do is to return some number. When an airport calls compared to another airport. And what we're comparing to is using the city name. So we're going to have to have access to the city name instance variables in each of these objects and we'd like to order those city names. But city names are just strings, and strings are objects, and strings can be compared because we can sort strings by alphabetical order. And so what we're going to do is really just be kind of lazy, and say someone else compare these two strings. And we just want to return the result of that comparison. So what we're returning here when we comparing two airport objects, is what happens when we compare the city name of our current object, the calling object, as compared to the city name of the other object. Okay, so let's try it out. Once we've implemented this compareTo method, what happens when we go ahead and try to sort a list of airport objects? So we go back to the main method of our airports class and we call Collections.sort on the list of airports. And now, beautifully, we get as our output the list of airports in sorted order based on the city name. So Agra in India comes first, and then Beijing in China, etc., etc. Cool. One more thing, when we first thought about this problem, we said we can compare airports in some different ways. Maybe we can sort based on the alphabetical order of the city name. But what about the country name. So what do we need to do in order to change our compareTo method in order to reflect the order of the country names? Well we just need to change the body of that method to instead of using the getCountry getter method for the, sorry, instead of using the getCity getter method for the city name of the airport, we're using getCountry. And that's really all there is to it. We just need to change that one line of code, and when we run the same Collections.sort method in the main method of the airport class, all of sudden our list is ordered based on the country names. We have Australia first, and then Canada, and then China etc. And so at this point, you're ready to dive back into the project and use the comparable interface and the compareTo method to compare markers in your project.

Explora nuestro catálogo

Inscríbete de manera gratuita y obtén recomendaciones personalizadas, actualizaciones y ofertas.

Coursera

Acerca de
Liderazgo
Empleo
Catálogo
Certificados
Certificados MasterTrack™
Grados
For Enterprise
For Government

Comunidad

Estudiantes
Socios
Desarrolladores
Probador beta
Traductores
Blog
Blog de Tecnología

Más

Términos
Privacidad
Ayuda
Accesibilidad
Prensa
Contacto
Directorio
Afiliados

Aplicación móvil

© 2019 Coursera Inc. Todos los derechos reservados.