Types

Loading...

来自 Duke University 的课程

Java 程序设计：使用软件解题

2039 个评分

Duke University

Java 程序设计：使用软件解题

2039 个评分

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

Building upon Duke’s “Programming and the Web for Beginners” course, you will grow in your ability to be a problem-solver and programmer by writing Java programs. We are excited that you've chosen to learn Java with us! You will soon be able to solve problems that you find interesting and useful by practicing a design process you will learn in this course. Java concepts presented in this course include basic control flow; object-oriented concepts including classes and methods; custom, open-source classes; and a design-implement-debug process that you can continue to leverage as you build your experience and knowledge of programming principles. The custom, open-source classes will provide a consistent application programming interface (API) so that you can write programs that access and transform images, websites, comma separated value (CSV) files and other data files using simple and accessible coding idioms built on the Java Iterable interface. You will learn to design, test, and debug programs and to find and read Java documentation that can serve as the basis for continued study of Java and programming. After completing this course you will be able to: 1. Edit, compile, and run a Java program; 2. Use conditionals and for loops appropriately in a Java program; 3. Use Java API documentation in writing programs. 4. Debug a Java program using the scientific method; 5. Develop a Java method to solve a specific problem; 6. Develop a set of test cases as part of developing a program; 7. Create a class with multiple methods that work together to solve a problem; and 8. Use divide-and-conquer design techniques for a program that uses more than one method.

从本节课中

Fundamental Java Syntax and Semantics

In this module, you will learn to write and run your first Java programs, including one program that prints “Hello!” in various countries’ languages and another where you will analyze the perimeters and other information of shapes. To accomplish these tasks, you will learn the basics of Java syntax and how to design stepwise solutions with programs. By the end of this module, you will be able to: (1) Download and run BlueJ, the Java programming environment for this course; (2) Access the documentation for the Java libraries specially designed for this course; (3) Edit, compile, and run a Java program; (4) Construct methods, variables, if else statements, and for each loops in Java; and (5) Use Iterables (like DirectoryResource) to run a program that iterates over multiples lines in a document or webpage or multiple files in a directory.

For Each Loops7:27

与讲师见面

Owen Astrachan
Professor of the Practice
Computer Science
Robert Duvall
Lecturer
Computer Science
Andrew D. Hilton
Associate Professor of the Practice
Electrical and Computer Engineering
Susan H. Rodger
Professor of the Practice
Computer Science

At this point, you have seen a variety of types such as Int, Point and FileResource.

But, what exactly is a type?

A type specifies how data should be represented,

interpreted, and operated on,

as well as, what operations you can do with it.

One important rule of computing is that,

everything is a number.

If you didn't learn about the everything is a number principle,

and whatever intro courses brought you here,

we'll give you some links to videos about it.

Specifically, this means that everything is stored in

the computer's memory as bits, ones and zeroes.

But, not all numbers mean the same thing.

Some numbers might mean plane numbers,

while others might mean letters,

and others might mean the locations of data in the computer's memory.

So, the type of a value specifies how to interpret those numbers.

It tells Java how to assign meaning to the ones and zeros stored in memory.

The type also specifies what operations you can perform on the data.

The type tells Java not only what you can do but how it should be done.

Let's talk about both of these points in more detail.

We just said that the type tells Java how to interpret the ones and zeroes in memory.

Let's talk about that a little bit more, huh?

On the left, we have

the conceptual representation of the program state that we have been working with.

There's a box for a variable called x.

On the right, we have a bunch of bits from the computer's memory.

The blue ones correspond to x.

But what do they mean for the value of x?

Well, if x is an int,

then these bits would mean it has a value of 1234567890.

We're not going into the details of how you can figure that out here,

nor do you need to know it for beginning Java programming.

But, if you take a computer organization class,

you will learn a lot more about how data is represented.

The point I want to make here is that,

if x had a different type,

like float, then the same bits would have different meaning.

These same ones and zeros would mean 1228890.25.

And if x were a string,

then the bits would be the location in the computer's memory of the actual string object,

which would have a sequence of characters.

Those would also be stored with a bunch of bits that would be interpreted as letters,

since your type would be char.

We also said that the type tells us what operations we can do and how they are done.

Consider this simple bit of code,

x + y. Is it legal?

And if so, what does it do?

To answer this, you need to know the types of both x and y.

If x or y are both ints,

then this code is legal and performs integer arithmetic.

If x and y are both strings,

then this code is also legal but perform string concatenation.

It makes a string with the letters of x,

first, then the letters of y, immediately after.

Notice that, even though the plus operation is legal for two different types,

we may perform that operation differently for one type than for the other.

If x and y are both points,

then this code is not legal.

While we're talking about types,

you might be wondering what you'd do if you need to convert between types.

The answer is that, it depends.

For some type conversions,

they can happen implicitly.

If you have an int and you need to convert it to

a double precision floating point number,

the compiler will just automatically insert the conversion for you without complaint.

The general rule is that,

you can use implicit conversion whatever the compiler will consider it safe.

Here, we are turning 3 into 3.0,

which is not a problem.

Note that the compiler does not consider the values,

only the types, when deciding if an implicit conversion is okay.

For some type conversions,

you can explicitly cast.

This means, that you tell the compiler

that even though what you're doing is questionable,

you are sure you want to do it.

Here, we are turning the double 3.14 into an int,

which will discard the fractional part,

leaving us with x = 3.

The compiler wants to be sure that we meant to do this,

so we explicitly cast by writing int in parentheses.

Other conversions require calling methods to calculate out the converted value.

For example, if we have this string "3",

and want to turn it into an integer,

we can't just directly cast it because the conversion is actually somewhat complicated.

Instead, we have to call a method like

Integer.parseInt which will perform the conversion.

The last thing we will mention about types is that,

there are two major categories of types in Java, primitives and objects.

There are eight primitive types: int,

double; char, boolean, long, float; byte, short.

We'll primarily use the first four of these.

Variables are primitive types hold their value directly in their box.

Primitive types don't have methods,

so you can't do dot method call on a primitive,

and they can't be null.

Although, each primitive type has an associated wrapper class,

which gives you an object to hold that primitive.

Everything else is an object type.

Some are built in the Java, like string.

Others are part of libraries that you might use,

like point or fileresource.

And yet, others are classes you will create yourself.

Whenever you make a class,

the class you make is its own new type.

Unlike primitives, the value of variables

of object types is an arrow pointing at the object.

This arrow is called a reference.

You can invoke methods on the object with dot method name,

and the reference can be null.

Meaning, it does not refer to any object.

If you do == on two objects,

you're checking to see if the arrows point at exactly the same object.

Okay, that's the basics of types.

We know it's a lot to absorb at once.

But, you'll get better with these ideas as you practice more Java.

探索我们的目录

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

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

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

通过 App Store 下载

通过 Google Play 获取