Java编程入门指南：浅显实用的CS教材与案例解析

需积分: 9 177 浏览量更新于2024-07-24 收藏 12.79MB PDF 举报

"《Java编程入门：一门跨学科的方法》是Princeton大学计算机科学专业的权威教材，由罗伯特·塞吉维克和凯文·韦恩合著。这本书旨在为Java编程初学者提供详尽的教程和实战案例分析，语言表达清晰，易于理解，适合那些对编程感兴趣但刚接触Java的人学习。作者以其深入浅出的讲解方式，帮助读者建立起坚实的编程基础。书中涵盖了Java语言的基础知识，包括数据类型、控制结构、函数、类与对象、异常处理等核心概念，同时也介绍了面向对象编程（Object-Oriented Programming, OOP）的核心理念。通过大量的例子和练习，读者可以逐步掌握Java编程的基本技巧和实践应用。在线预览部分展示了该书的一些特色和教学风格，可能会包含一些代码示例和互动式的学习环节，使学习过程更具趣味性和互动性。此外，教材还注重培养学生的实践能力，鼓励学生通过解决实际问题来提升编程技能。值得注意的是，书中的一些设计者、编辑和制作团队成员名单体现了背后的专业支持和严谨的出版流程。例如，封面图像由作者创作，而版权信息则列出了相应的版权持有者和许可协议，确保了知识产权的尊重。对于想要踏入Java编程世界的人来说，《Java编程入门：一门跨学科的方法》是一本不可或缺的参考书，它不仅提供了理论知识，还有助于读者在实践中不断成长。无论你是计算机科学专业的学生，还是希望转行进入IT行业的业余爱好者，都可以从中受益匪浅。"

Elements of Programming

% javac HelloWorld.java

% java HelloWorld

Hello, World

PROGRAM 1.1.1 IS AN EXAMPLE OF

a complete Java program. Its name is HelloWorld,

which means that its code resides in a ﬁle named HelloWorld.java (by convention

in Java). The program’s sole action is to print a message back to the terminal win-

dow. For continuity, we will use some standard Java terms to describe the program,

but we will not deﬁne them until later in the book:

PROGRAM 1.1.1

consists of a single

class named HelloWorld that has a single method named main(). This method uses

two other methods named System.out.print() and System.out.println() to

do the job. (When referring to a method in the text, we use () after the name to

distinguish it from other kinds of names.) Until

SECTION 2.1

, where we learn about

classes that deﬁne multiple methods, all of our classes will have this same structure.

For the time being, you can think of “class” as meaning “program.”

The ﬁrst line of a method speciﬁes its name and other information; the rest is

a sequence of statements enclosed in braces and each followed by a semicolon. For

the time being, you can think of “programming” as meaning “specifying a class

Program 1.1.1 Hello, World

public class HelloWorld

{

public static void main(String[] args)

{

System.out.print("Hello, World");

System.out.println();

}

This code is a Java program that accomplishes a simple task. It is traditionally a beginner’s ﬁrst

program. The box below shows what happens when you compile and execute the program. The

terminal application gives a command prompt (% in this book) and executes the commands

that you type (javac and then java in the example below). The result in this case is that the

program prints a message in the terminal window (the third line).

!"#$%&'(')!"*+,,,8 ./01/23,,,0425,67

1.1 Your First Program

name and a sequence of statements for its main() method.” In the next two sec-

tions, you will learn many different kinds of statements that you can use to make

programs. For the moment, we will just use statements for printing to the terminal

like the ones in HelloWorld.

When you type java followed by a

class name in your terminal application, the

system calls the main() method that you

deﬁned in that class, and executes its state-

ments in order, one by one. Thus, typing

java HelloWorld causes the system to call

on the main() method in

PROGRAM 1.1.1

and

execute its two statements. The ﬁrst state-

ment calls on System.out.print() to print

in the terminal window the message be-

tween the quotation marks, and the second

statement calls on System.out.println()

to terminate the line.

Since the 1970s, it has been a tradition that a beginning programmer’s ﬁrst

program should print "Hello, World". So, you should type the code in

PROGRAM

1.1.1 into a ﬁle, compile it, and execute it. By doing so, you will be following in the

footsteps of countless others who have learned how to program. Also, you will be

checking that you have a usable editor and terminal application. At ﬁrst, accom-

plishing the task of printing something out in a terminal window might not seem

very interesting; upon reﬂection, however, you will see that one of the most basic

functions that we need from a program is its ability to tell us what it is doing.

For the time being, all our program code will be just like

PROGRAM 1.1.1

, ex-

cept with a different sequence of statements in main(). Thus, you do not need to

start with a blank page to write a program. Instead, you can

sCopy HelloWorld.java into a new ﬁle having a new program name of

your choice, followed by .java.

sReplace HelloWorld on the ﬁrst line with the new program name.

sReplace the System.out.print() and System.out.println() statements

with a different sequence of statements (each ending with a semicolon).

Your program is characterized by its sequence of statements and its name. Each

Java program must reside in a ﬁle whose name matches the one after the word

class on the ﬁrst line, and it also must have a .java extension.

main() method

body

name

statements

Anatomy of a program

text file named

HelloWorld.java

public class HelloWorld

{

public static void main(String[] args)

{

System.out.print("Hello, World");

System.out.println();

}

!"#$%&'(')!"*+,,,1 ./01/23,,,0425,67

1.1 Your First Program

Input and Output Typically, we want to provide input to our programs: data

that they can process to produce a result. The simplest way to provide input data is

illustrated in UseArgument

(PROGRAM 1.1.2)

. Whenever UseArgument is executed,

it reads the command-line argument that you type after the program name and

prints it back out to the terminal as part of the message. The result of executing

this program depends on what we type after the program name. After compiling

the program once, we can run it for different command-line arguments and get

different printed results. We will discuss in more detail the mechanism that we use

to pass arguments to our programs later, in

SECTION 2.1

. In the meantime, you can

use args[0] within your program’s body to represent the string that you type on

the command line when it is executed, just as in UseArgu-

ment

Again, accomplishing the task of getting a program

to write back out what we type in to it may not seem in-

teresting at ﬁrst, but upon reﬂection you will realize that

another basic function of a program is its ability to re-

spond to basic information from the user to control what

the program does. The simple model that UseArgument

represents will sufﬁce to allow us to consider Java’s basic

programming mechanism and to address all sorts of inter-

esting computational problems.

Stepping back, we can see that UseArgument does neither more nor less than

implement a function that maps a string of characters (the argument) into another

string of characters (the message printed back to the terminal). When using it, we

might think of our Java program as a black box that converts our input string to

some output string. This model is attractive because it is not only simple but also

sufﬁciently general to allow completion, in principle, of any computational task.

For example, the Java compiler itself is nothing more than a program that takes

one string of characters as input (a .java ﬁle) and produces another string of

characters as output (the corresponding .class ﬁle). Later, we will be able to write

programs that accomplish a variety of interesting tasks (though we stop short of

programs as complicated as a compiler). For the moment, we live with various lim-

itations on the size and type of the input and output to our programs; in

SECTION

1.5, we will see how to incorporate more sophisticated mechanisms for program

input and output. In particular, we can work with arbitrarily long input and output

strings and other types of data such as sound and pictures.

input string

Alice

Hi, Alice. How are you?

black box

output string

A bird’s-eye view of a Java program

!"#$%&'(')!"*+,,,3 ./01/23,,,0425,67

Elements of Programming

Q&A

Q. Why Java?

A. The programs that we are writing are very similar to their counterparts in sev-

eral other languages, so our choice of language is not crucial. We use Java because

it is widely available, embraces a full set of modern abstractions, and has a variety

of automatic checks for mistakes in programs, so it is suitable for learning to pro-

gram. There is no perfect language, and you certainly will be programming in other

languages in the future.

Q. Do I really have to type in the programs in the book to try them out? I believe

that you ran them and that they produce the indicated output.

A. Everyone should type in and run HelloWorld. Your understanding will be

greatly magniﬁed if you also run UseArgument, try it on various inputs, and modify

it to test different ideas of your own. To save some typing, you can ﬁnd all of the

code in this book (and much more) on the booksite. This site also has information

about installing and running Java on your computer, answers to selected exercises,

web links, and other extra information that you may ﬁnd useful or interesting.

Q. What is the meaning of the words public, static and void?

A. These keywords specify certain properties of main() that you will learn about

later in the book. For the moment, we just include these keywords in the code (be-

cause they are required) but do not refer to them in the text.

Q. What is the meaning of the //, /*, and */ character sequences in the code?

A. They denote comments, which are ignored by the compiler. A comment is either

text in between /* and */ or at the end of a line after //. As with most online code,

the code on the booksite is liberally annotated with comments that explain what it

does; we use fewer comments in code in this book because the accompanying text

and ﬁgures provide the explanation.

Q. What are Java’s rules regarding tabs, spaces, and newline characters?

A. Such characters are known as whitespace characters. Java compilers consider

all whitespace in program text to be equivalent. For example, we could write Hel-

!"#$%&'(')!"*+,,,:2 ./01/23,,,0425,67

剩余356页未读，继续阅读

我是郭俊辰

粉丝: 217
资源: 2

Java编程入门指南：浅显实用的CS教材与案例解析

Java编程入门教程[整理].pdf

Java编程入门.pdf

java编程入门到精通

Java编程思想笔记

java 编程十五讲

java入门经典pdf

黑马程序员java基础入门电子书

java编程思想 pdf代码

java入门1 2 3 pdf

java编程思想word文档

最新资源