Java速查手册：综合Java参考材料

需积分: 9 166 浏览量更新于2024-07-19 收藏 1.62MB PDF 举报

"这是一份由Paul N. Hilfinger编写的关于Java的参考材料，涵盖了从基础到进阶的各种Java编程知识点，旨在帮助读者快速掌握Java语言。文档中包含了Java的概述、基本程序结构、编译与执行、简单值与表达式、条件执行、数组、以及实例分析等内容。" 这篇文档是为那些希望通过阅读参考资料快速学习Java编程语言的人准备的。作者Paul N. Hilfinger是加州大学伯克利分校的教授，他在文档的版权信息中感谢了多位人士对其前期版本错误的指正。文档的主要内容分为多个部分： 1. **Java Overview** - 提供了对Java语言的基本介绍，包括其基本的程序结构。 - **基本程序结构** - 描述了如何编写一个简单的Java程序，包括类定义、主方法等。 - **编译与执行** - 解释了如何使用Javac编译器将源代码转换为字节码，以及如何使用Java虚拟机（JVM）运行程序。 2. **简单值与表达式** - 讨论了Java中的数据类型、数值表示、算术运算、比较和逻辑操作。 - **写数字** - 介绍了如何在Java中表示整数和浮点数。 - **算术运算** - 包括加减乘除、取余和幂运算等。 - **比较和逻辑操作** - 涉及到等于、不等于、大于、小于等比较操作，以及逻辑与、或、非等操作。 - **字符串** - 讨论了String类的使用，包括创建、连接和操作字符串的方法。 - **静态方法** - 引入了类级别的方法，用于抽象计算过程。 3. **条件执行** - 阐述了如何根据条件来控制程序流。 - **if语句** - 基本的条件判断结构。 - **条件表达式** - 如三元运算符，可以在表达式中进行条件判断。 - **case分析和switch语句** - 多分支选择结构，适用于多种情况的处理。 4. **数组I：命令行** - 介绍了如何在命令行中使用数组，以及数组的声明、初始化和遍历。 5. **Example: Finding Primes** - 提供了一个找出素数的例子，展示了如何在实际编程中应用前面的知识点。 - **从顶部开始** - 一种从最大可能的素数开始搜索的方法。 - **从底部开始** - 另一种从最小可能的素数开始搜索的方法。 - **在中间相遇** - 使用二分查找策略，提高搜索效率。这份文档详尽地介绍了Java编程的基础知识，对于初学者来说是一份宝贵的参考资料。它不仅涵盖了语言的基础概念，还通过示例程序展示了如何实际应用这些概念，有助于读者加深理解并提升编程技能。

16 CHAPTER 1. JAVA OVERVIEW

1.3.4 St rings

In programming-language jargon, a string is a sequ en ce of characters. We write

strings in double quotes, using a backslash where n eeded to indicate special char-

acters, including double quotes and b ackslashes:

System.out.println ("Simple string.");

System.out.println (""); // An empty string

System.out.println ("Say \"Hello.\""); // \" is double quote

System.out.println ("Name:\tJohn"); // \t is tab

System.out.println ("\\FOO\\BAR");

System.out.println ("One thing\nThe other thing");

These statements print (on Un ix systems):

Simple string.

Say "Hello."

Name: John

\FOO\BAR

One thing

The other thing

The newline character (notated \n) denotes the end-of-line on Unix systems. This

is not, unfortunately, universal, which is why I’ve used println rather than \n to

put things on separate lines (println “does the right thing” at the end of a line for

whatever system you use).

Characters, the components of strings, have their own literals, which are enclosed

in single quotes, with the s ame back-slashing notation:

’A’ ’\t’ ’\’’ ’"’ ’\n’

The + operator works on strings, but in that case means “concatenate”, as in

System.out.println ("The value of" +

" 17+25 is " + (17+25) + ".");

which prints

The value of 17+25 is 42.

You might well protest at this point that (17+25) yields an integer, not a string.

This is correct; conveniently, though, the + operator is s mart enough that when one

of its operands is a string, and the other isn’t, it converts the other operand to a

string. In fact, underneath the hood, the println method ultimately prints strings,

and the variations that work on other types ﬁrst perform this same conversion.

There are quite a few other operations on strings, of which some of the more

important are these:

1.3. SIMPLE VALUES AND EXPRESSIONS 17

("19-character string").length () =⇒ 19 length of string

("abcd").charAt (3) =⇒ ’d’ get a character (num-

ber from 0)

("abcd").equals ("abcd") =⇒ true compare contents

("Hello, world!").substring (7, 12) =⇒ "world" substring between

start and end posi-

tions

("Hello, world!").substring (7) =⇒ "world!" substring starting at

given position

The .equals method here is interesting. You might think that == would work, but

for reasons we’ll see later, that is not a reliable way to compare strings.

1.3.5 Static Methods: Abstracting Computation

Method (function) deﬁnition is the most basic abstraction mechanism in a typical

programming language. It enables you to “deﬁne a new verb” for later u s e in your

program, making it unnecessary to write, r emember, or even know the details of

how to perform some action.

In Java, there are static methods (also called class methods) and non-static (or

instance) methods. We’ll look at instance methods later. S tatic methods correspond

to plain, ordinary functions, subprograms, or procedures in other programming

languages (such as C, Pascal, Fortran, Scheme, or Basic). We’ve already s een

examples of static method deﬁn ition (of the main method).

The basic syntax is r elatively easy:

A static T

N (T

, T

, ...) {

}

where

• T

, T

, etc., denote types of values. T

is the type of value returned (produced,

yielded) by the method, and the other T

are the formal-parameter types, the

types of values that may be passed to the method. In Java, unlike dynamically

typed languages such as Scheme or the scrip ting languages Python and Perl,

one must be speciﬁc about the types of most quantities. You can indicate that

a method does stuﬀ (printing, for example), but does not return a value, by

using the special “type” void for T

• A is one of the keywords public, private, protected, or it is simply missing

(the default). It indicates the access of the method— what other parts of the

program may call it. The public modiﬁer, as you might guess, means that the

method may be called from anywhere. The private modiﬁer restricts access

to the same class. (See §1.14)

• N is the name by which the method is known. A method deﬁnition always

occurs inside a class deﬁnition. The full name of a static method N deﬁned in

18 CHAPTER 1. JAVA OVERVIEW

a class C is C.N (dot means “that is deﬁned in”). However, the s imple name

N works within the same class.

• N

, etc., are the formal parameters. These are names by which the body of

the method (B) can refer to the values passed to it.

• { B } is the body of the method. B is a sequen ce of statements that perform

whatever computation the method is su pposed to perform (B may be empty

if the metho d does nothing).

• The header of the method deﬁnition—everything except the body—deﬁnes

its signature, which consists of its name, return type, and formal-parameter

types.

So far, the only statements we’ve seen are method calls (to println). We’ll

see more later, but there’s one particularly important ones for methods that return

values: the statement

return E;

means “end this call to the metho d, causing it to yield the value E (an expression).”

Here are two examples:

/** The square of X. */

public static double square (double x) {

return x*x;

}

/** The distance between points (X0, Y0) and (X1, Y1). */

public static double dist (double x0, double y0, double x1, double y1) {

return Math.sqrt (square (x1 - x0) + square (y1 - y0));

// NOTE: Math.sqrt is a standard square-root function */

}

These two examples also illustrate some documentation conventions that I’ll be

using th roughout. Comments beginning with ‘/**’ are, by convention, called docu -

mentation comments. They are to be us ed before deﬁnitions of things to describe

what those things do or are for. In the case of methods, I refer to the parameter

names by writing them in upper case (the idea being that this is a way to set them

oﬀ from the rest of the text of the comment in a way that does not depend on

fancy fonts, colors, or the like). At least one tool (called javadoc) recognizes these

comments and can process them into on-line d ocumentation.

1.4 Conditional Execution

To do anything very interesting, programs eventually have to make decisions—to

perform diﬀerent calculations depending on the data. There are several constructs

to represent this in J ava. Here, we’ll consider the simplest.

1.4. CONDITIONAL EXECUTION 19

1.4.1 If statements

An if-statement has one of the forms

if (condition) then-part

// or

if (condition) then-part else else-part

(Normally, th ou gh, we lay these statements out on separate lines, as you’ll see).

The condition is a boolean expression. If it evaluates to true, the program executes

the then-part (a statement), and otherwise the else-part, which simply defaults to

the empty statement if absent.

We’ll often need to have then-part or else-part contain more than one statement.

The trick used for this purpose (and for other constructs that have a “statement”

part that needs to be several statements) is to use a kind of statement called a block.

A block consists of any number of statements (including zero) enclosed in curly

braces ({ }). Unlike other statements you’ve seen, it does not end in a semicolon.

For example:

if (3 > 4) {

System.out.println ("3 > 4.");

System.out.println ("Looks like we’re in trouble.");

} else

System.out.println ("OK");

1.4.2 Conditional Expressions

The expression C ? E

: E

yields either the value of E

or E

, depending on

whether C evaluates to true or false. That is, ‘?’ means roughly “then” and ‘:’

means “otherwise”, with an invisible “if” in front. This peculiar-lo oking tern ary

operator is not commonly used in C, C++, or Java, perhaps because it, well, looks

peculiar. It is only your author’s desire for balance th at prompts its inclusion here.

Here are some examples:

System.out.println (3 < 4 ? "Less" : "More"); // Prints Less

System.out.println (4 < 3 ? "Less" : "More"); // Prints More

// The next two mean the same, and print 3.1

System.out.println (1 < 0 ? 1.1 : 1 > 2 ? 2.1 : 3.1);

System.out.println (1 < 0 ? 1.1 : (1 > 2 ? 2.1 : 3.1));

The expressions after ‘?’ and ‘:’ must be the same type of thing; 3<4 ? 1 : "Hello"

is erroneous.

1.4.3 Case analysis and the Switch Statement

From time to time, you’ll ﬁnd yourself in a situation where you need to break some

subproblem down into several cases. This is something to avoid if possible, but not

all problems lend themselves to simple, unconditional formulae. You can always get

by with multiple uses of the if statement, like this mathy example:

剩余263页未读，继续阅读

「已注销」

粉丝: 0
资源: 4

Java速查手册：综合Java参考材料

reference:为开发人员共享快速参考速查表

java上传文件源码-Assorted-Java-Source-Reference-Code:初始文件上传

java-assorted:JVM 中的快速概念测试（不仅限于 Java）

assorted_java_projects:Java中数据结构的实现

java拼图源码代码-Assorted-Projects:包含其他C++/Java/Objective-C项目源代码的存储库

assorted-benchmarks:适用于各种Java集合的BumbleBench基准测试

assorted_layout_widgets:颤振包

spaghettimod-assorted:各种模块的spaghettimod的load.d脚本

Assorted-Examples:按语言分类的各种项目

assorted:向 ActiveRecord 模型添加排序范围 `asc` 和 `desc`

最新资源