Explore
For Enterprise
Join for Free
Log In

Arts and Humanities
- View all Arts and Humanities
- History
- Music and Art
- Philosophy
Business
Computer Science
Data Science
- View all Data Science
- Data Analysis
- Machine Learning
- Probability and Statistics
Information Technology
- View all Information Technology
- Cloud Computing
- Security
- Data Management
- Networking
- Support and Operations
Health
Math and Logic
Personal Development
Physical Science and Engineering
- View all Physical Science and Engineering
- Electrical Engineering
- Mechanical Engineering
- Chemistry
- Environmental Science and Sustainability
- Physics and Astronomy
- Research Methods
Social Sciences
- View all Social Sciences
- Economics
- Education
- Governance and Society
- Law
Language Learning
- View all Language Learning
- Learning English
- Other Languages
Degrees
Certificates

Explore all of Coursera

Browse
Search
For Enterprise
Log In
Join for Free

Support: Memory Model Drawing Example

Loading...

Object Oriented Programming in Java

University of California San Diego

4.7 (3,559 ratings) | 160K 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,559 ratings)

5 stars
2,725 ratings
4 stars
689 ratings
3 stars
97 ratings
2 stars
26 ratings
1 star
22 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

Memory Models, Scope, and Starting the Project

We hope you’re excited about the project that we're starting to build -- we sure are! In this second part of this week, we'll walk you through setting up your system and working through your first assignment so you'll be having fun with it in no time. Before that though, we'll finish going over some of the fundamentals fundamentals of object oriented programming. Specifically, being able to trace code is a key skill in becoming a stronger programmer. Like the end of last week, the first part of this week might be a bit of a review of material you already learned in your first Java programming course. If that’s the case, you are always welcome to skip to the first graded assignment on Objects, Memory Models, and Scope.

Core: Drawing Memory Models with Primitive Data5:06

Support: Memory Models for Primitive Types3:21

Support: Setting Up and Running Examples in Eclipse2:23

When I Struggled: Compiling and Running Code0:55

Core: Drawing Memory Models with Objects8:28

Concept Challenge: Memory Models 15:44

Concept Challenge: Memory Models 25:10

Support: Memory Model Drawing Example5:31

Taught By

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

Transcript

[SOUND] In this support video,

we'll be practicing two really important skills.

First we'll be tracing code using the memory models that we've been talking

about before, for both object and primitive data.

But we'll also be developing a skill of tracing code and talking about

it in high level terms, beyond step by step what each statement does.

Now you want to make sure that you are ready to participate.

Get a pencil out and work with me through this.

You'll learn much better if you're working through it yourself as well.

So let's start with a piece of code that we'll be thinking about and

take a few seconds to read it carefully and try to explain, in your own words,

what this piece of code does.

All right, welcome back.

It's very useful to try to think about how the code and

the syntax that we have in Java translate to steps and

procedures that we can understand as high level human beings.

So for example, if we're thinking about this in words.

What we might say is that we create a couple of objects and

then we try to assign those objects to one another.

When we say assign objects to one another, that's very imprecise and so

this gives us an added perspective on the benefit of tracing code and

on the benefit of the precision that comes with memory model.

All right, so let's see what we do when we trace the code.

We remember that in order to declare SimpleLocation type objects,

what we need is to think about the SimpleLocation class.

And we're using the class definition that you've seen in the core videos for

this module.

So you'll be fairly familiar with this definition, but

you can look at it here as well.

The first line of code that we have is a declaration and an assignment statement.

We're reserving some space and memory, we're labeling it ucsd, and

what we would like to have there is a reference to a new object.

That new object is of type SimpleLocation, and

it's initialized using the constructor to some values.

So what that means is we have a box in our memory model.

It's labeled by the name of the variable UCSD and

we point to this new object that we've created whose instance variables,

latitude and longitude are set to 32.9 and negative 117.2 respectively.

And that's all there is to that first line.

Shall we go on to the next line, and that next line has exactly the same form.

We're declaring a variable, that variable is of type SimpleLocation,

and so we have a reference to a new object.

That object is being created by the constructor and

those instance variables have their own values.

And notice that those instance variables for this new object are completely

separate from the variables that we had for the previous object.

We've constructed completely new copies of these objects.

All right, now we get to the third line.

In this third line we're not creating any new objects,

we're not declaring any new variables.

What we're going is we're doing an assignment statement.

And an assignment statement, what we would like to do is to assign the value

on the right-hand side to the variable on the left-hand side.

And so let's think a little bit more about what's actually stored

inside these variables.

So UCSD, that box in our memory model, has an arrow to an object but

remember that arrow to the object is our visual shorthand for

saying we have stored the address in memory of that object.

So something like @15.

15 is a made up number here, it's to indicate some address,

the address of the object that we created before.

Similarly, the box associated with the variable kumamoto stores an address,

which is the address that the reference to a new object of type SimpleLocation.

So it's got a different address, because we've got two different objects.

Now what we need to do in this assignment statement is we need to copy

the contents of the box kumamoto to the box ucsd.

And so that means that the @34 reference gets copied into the ucsd box.

And so if we think that in terms of our memory model,

what's happening here is that now both of these variables refer to the same object.

The object of the address @34.

Okay. So that's what

we've done with this assignment statement.

But now what happens when we go to the last statement in this code snippet?

Here what we're trying to do is, we're trying to assign the value

that's stored in the variable ucsd to the variable kumamoto.

But if we look at that value that's stored at the variable ucsd, it's the address

of the object that we had before that was also pointed to by kumamoto.

So actually executing this assignment does nothing at all.

It's saying copy @34 to kumamoto and

that was the previous value of kumamoto before as well.

So at the end of executing this line of code, if we were to

test it using the strategy we talked about before by throwing it into a class and

executing into the main method of class and then running that piece of code.

Then we see both UCSD and

Kumamoto both of those variables pointed to the same object.

With the latitude and

longitude variables set as we did when we constructed the Koumoto object.

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.

Download on the App Store

Get it on Google Play

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

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