Concept Challenge: Memory Models 2

Loading...

来自 University of California San Diego 的课程

面向对象 Java 程序设计

3219 个评分

University of California San Diego

面向对象 Java 程序设计

3219 个评分

课程 3（共 4 门，Specialization Object Oriented Programming in Java）

你是否曾想过大型软件项目诸如Google搜索引擎是如何开发的？本课程将帮助你超越平凡编程，去学习设计和开发更加复杂的Java软件项目（尽管还没到Google搜索引擎那种级别！）我们会探索如何将一个大的项目分解为层次结构的类，以及如何通过现有的库来增强项目的功能。我们也会探究一些搜索和排序的核心算法。在学习过程中，你将要开发一个令人兴奋的有着图形用户界面（GUI）的交互式应用程序。我们期待本课能启发你去创造。你即将进入课程项目，每节课所涉及的原理概念都设计成可直接应用于项目功能拓展。视频课程同时包括核心课程内容和现实中的软件工程师的来信和故事，与正在学习本课的真实学生之间的对话，以及一些你遇到困惑时可去观看的补充视频。（本课程若发现字幕错误请发送邮件到caesarguangli@hotmail.com，谢谢！）

从本节课中

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

与讲师见面

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

As we can see working through this module,

it's important that we have this concept challenges.

So, the reason we're doing these again is that

it's important test on your own understanding.

You can listen to us talk about the material but till you really tried to

apply it, you don't know for sure whether your understanding it correctly.

So this is an opportunity for you to identify potential misconceptions in your

standard or to gain confidence in the fact that you're understanding it properly.

Process again, we're gonna pause, you're gonna try to solve it yourself.

You're gonna discuss it with potentially other learners around you.

You're gonna watch UCSD learners talk about the concepts and

then you're gonna confirm your understanding with our explanation.

So the problem for this one is to walk through this code.

Again, always start executing in main.

In the very end of main, there's going to be a print.

The question is what gets printed?

>> Hi, I'm Tenki.

>> Hi, I'm Peter.

>> Hi, I'm Joe.

>> All right.

So let's go ahead and get started.

So, I guess we can all agree.

So location one is going to create a new SimpleLocation with those values, and

location two is going to create another SimpleLocation with those values as well.

>> And we're talking about objects right here?

>> Yeah, so we're gonna have two different objects, location one and location two.

And what I got stuck at was when location one equals location two.

So what I was thinking was that the values inside loc2

are actually going to copy over into loc1.

>> Oh, like a whole new object?

>> Well, not exactly a whole new object, but just the values of the latitude and

the longitude into loc1.

So, currently.

>> So it would look like rewrite the object.

>> Yeah, yeah, so currently loc1 has 39.9.

For the latitude.

And well I was thinking that location two's latitude,

55.8, would overwrite that.

Am I right or?

>> I think those are like two objects right?

Like they're separate.

So I think the third eye is just change of reference here.

So it won't like overwrite like the every member variable here.

>> So rewrite the arrow?

Where location one is pointing?

>> Right.

>> So location one is now going to reference to the same object that location

two is referencing.

>> You just follow the arrow.

>> So that means that location one's values do change, but

it's just because it's referencing a new object.

>> Correct. >> Yeah.

>> Yeah. >> All right.

So when loc1.lat gets -8.3 that means that

the latitude of loc1 changes to -8.3 but

since that's the same object referenced by location two.

Does that mean location two's latitude changes to -8.3?

>> Yeah, I think so.

>> Yeah, because it's all just one object.

>> That was a great discussion by the UCSD learners.

Let's walk through the code again one more time.

So you're gonna start in main.

You're gonna create a simple location reference,

loc1 that's gonna point to an object.

And we just did those memory models so

we'll do this one a little bit more quickly.

We're gonna recognize that this is gonna create a reference loc1 pointing

to an object on the heap which has these values.

We're then gonna create a second object.

This one's going to be loc2, and

loc2 is pointing to a different object on the heap.

The key part of this problem is what happens in this next statement.

What happens when you assign loc1 to be equal to loc2?

What really happens there?

To understand that,

we're gonna have to think about what those references really mean.

So loc2 points to this object, and

what that really means is that loc2 has a numeric value,

which is an address for that object on the heap.

And that object on the heap actually has that address.

So you can think of loc1.

We're throwing in arbitrary addresses here.

But loc1 has address 1, it points to that object on the heap.

Loc2 has address 2, and it's pointing to that object on the heap.

When you do loc1 equals loc2, you're really copying essentially the reference.

That means is you're copying the address.

So loc1 is now gonna point to the exact same thing that loc2 does.

Now I'm gonna do loc1.lat equals this negative value.

And that really is loc1 points the same thing that loc2 points to.

And it's gonna change that object point2 by loc1.

Then we're gonna go to print this we're gonna print using the loc2 reference but

again loc2 and loc1 are pointing to the exact same thing on the heat so

when loc2 prints out its lat and lon it's gonna print out -8.3, and 37.6.

Again, drawing these memory models helps you understand how to work through these

problems.

探索我们的目录

免费加入并获得个性化推荐、更新和优惠。

Coursera 致力于普及全世界最好的教育，它与全球一流大学和机构合作提供在线课程。

© 2019 Coursera Inc. 保留所有权利。

通过 App Store 下载

通过 Google Play 获取