Explore
For Enterprise
Join for Free
Log In

Browse
Search
For Enterprise
Log In
Join for Free

Core: Public vs. Private

Loading...

Object Oriented Programming in Java

University of California San Diego

4.7 (3,633 ratings) | 170K Students Enrolled

Course 3 of 4 in the Object Oriented Programming in Java Specialization

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!

Skills You'll Learn

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

Reviews

4.7 (3,633 ratings)

5 stars
2,784 ratings
4 stars
701 ratings
3 stars
97 ratings
2 stars
27 ratings
1 star
24 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.

HW

Mar 21, 2016

It is good!!! I learnt a bit of Java beforehand but not the object oriented concept. Would definitely attend the courses by UC San Diego again as well as pay for the course when I can afford it!

From the lesson

Welcome and Project Overview: Visualizing Data

Welcome to the first week of our course. In this week, we'll get started by introducing ourselves and the Google engineers who will be making appearances throughout the course. We'll also give you of the unique video series we provide and help you understand how to navigate the course to get the most out of it given your background and learning speed. Finally, we'll jump right into objects and designing classes. This might be a bit of review for some of you who might have learned this in your first programming course. If that's the case, feel free to jump ahead to the Practice Quiz at the end of the week. Let's get started!

Introduction: Classes and Objects0:25

Core: Defining Classes and Creating Objects11:46

When I Struggled: Objects1:08

Core: Overloading Methods6:59

Core: Public vs. Private7:07

In the Real World: Public vs. Private access0:27

Taught By

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

Transcript

[MUSIC] Okay, in this next video we'll layer on some more details of building classes in Java. We're gonna talk about the keywords public and private and protecting your data and methods inside your classes. So by the end of this video you'll be able to describe what those keywords mean and their effect on who can access the data and methods inside your classes. And you'll be able to also talk about how to use getters and setters to allow customized access to the data inside of your classes. So as usual, we're gonna go back to the SimpleLocation class that we've been developing. So these class, as you know, has two member variables, latitude and longitude. And we originally declared them both to be public. So let's take a closer look at what that means. What that means is that anyone can access these member variables from any class at all. So when I create a new object of type SimpleLocation, I can get at the member variable latitude or the member variable longitude to read its value or to change its value. So if I go over here into the LocationTester class, I see that I've created two new SimpleLocation objects. I can change the value of latitude inside the object stored in lima. That's totally okay, because that member variable is declared to be public. So I can access it from anywhere. Similarly for methods, I've declared my method distance to be public. Which means that I can access that method anywhere. So over here, back in my LocationTester class I'm calling the distance method, which is also totally allowed because again, that method is public. On the other hand, if I were to declare my member variables private, what that would mean is that those variables would only be accessible from within the SimpleLocation class itself. So only inside this class definition. Nowhere else. No one else has access to either read or write those variables. Same thing goes for methods. If I make a method private, I can only call that method within the class I'm defining, and nowhere else. So, if we look at what that means, if we look at this constructor, these two lines of code are just fine. I'm using this.latitude to access the member variable latitude and this.longitude to access the member variable longitude. Perfectly okay because I'm inside the class SimpleLocation. However, if I go back to that class LocationTester, and look at this line here that's trying to change the value of latitude in the SimpleLocation stored in the variable lima, that's no longer allowed. Because now I've said that that latitude variable is private. It can only be accessed from within the SimpleLocation class. And we're no longer in the SimpleLocation class. We're now over here in the main method, inside LocationTester. So that would cause an error. So, it's actually, despite this error that just got caused, it's actually a good idea to make your member variables private. Because you as the class designer want to really have ultimate control over who gets to see and change the data that's stored in each object of the class that you're creating. So as a rule of thumb, always make your member variables private. Now methods can either be public or private, depending on whether they're for world use, like the distance method. Or whether they're maybe just helper methods that are designed to be used only within that class itself. We'll talk more about that as we start talking about more sophisticated class design. But, for now, let's focus on this rule of thumb that we should make our member variables private. So, if our member variables are private, nobody else can access them. They can't see their values, they can't change them. So, that seems like a bit of a problem. We probably sometimes want to give a little bit more access to the member variables in our class than that. So the way we get around that problem is through the use of what are called getters and setters. So this is an example right here of a getter, and the purpose of a getter is to take the value of a member variable that's private and expose it outside of that class. So you can see this getter here gets the value of the member variable latitude, which is private, and returns it to the outside world. So the variable itself is still private but now I can gain access to that variable by calling this getter. So if we go back over here to the code, we can see that if I try to access the variable directly say, print it out I get an error, but when I call that getter method, that's perfectly fine. So I can actually get access to the value of that latitude variable through the getter. And now notice that in this code so far, going back here, I haven't provided my user of my class with any way to actually set or change the value of latitude. And that may be what I intend as the class designer, that once that latitude variable gets set in the constructor, I may never want anybody to change it again. And in that case, I would just simply provide a getter and not provide any way for the user to change the value of the variable. But, let's say I actually do want to allow somebody to change the value of the variable. In that case I would provide what's called a setter. So, here's my setter. What it does is it takes in a value, lat, and it changes the value of the private member variable to the value that was passed in by the user. So a setter sets the value of our member variable, usually a private member variable. So now I've got a getter and a setter for my latitude variable. And you might be thinking, I would be thinking if I were you, why didn't we just make that member variable public? If we're exposing the ability to change it and read it, we might as well just make it public, right? So here's why, having the getter and the setter allows us more control as class designers. So let's say we want to allow the user to change the value of the latitude. But we're little bit unsure that the user of our class will know what they're doing when it comes to legal latitude values. So we can put some precautions in place that allow the user to change the value of that latitude, but only to values that are legal latitude values. So the way we would do this is we would modify our setter to rather than just blindly accepting whatever argument was passed in, we would have some checks, some logic inside of that method that said okay, if it's out of range of -180 to 180 then that's not a legal value. So we're gonna print out an error, inform the user of our class that, hey, you tried to set your latitude variable to an illegal value. That's probably some bug in your code, so you should probably go check that out. And not change the value that's stored in the latitude variable. Otherwise, we can happily accept the value because it's within the legal range and change the value of that variable. All right, so that's it for the details of classes and objects. You now know all the basics of creating classes and objects. Next you'll take a short practice quiz and then move on to the next module.

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