Java编程精要：MIT出版社

需积分: 0 148 浏览量更新于2024-07-27 收藏 874KB PDF 举报

"Java Precisely MIT Press 是一本由Peter Sestoft编著，MIT Press出版的关于Java编程语言的专业书籍。这本书深入详细地探讨了Java的各个方面，旨在精确地阐述Java语言的核心概念和技术。" 书中的内容涵盖了Java的多个关键知识点，包括： 1. **运行Java：编译、加载与执行** - 这一部分介绍了Java程序的基本生命周期，包括如何通过编译器将源代码转化为字节码，然后通过Java虚拟机（JVM）进行解释执行。还可能涉及类路径（class path）设置、主类识别以及异常处理机制。 2. **名字与保留名字** - 描述了Java中的标识符规则，哪些字符可以用于变量、类或方法的名字，以及Java语言中预定义的一些保留关键字，它们有特殊的含义，不能用作自定义标识符。 3. **Java命名约定** - 强调了Java编程中遵循的一系列命名规范，如类名、变量名、常量名应采用驼峰式命名，包名全小写等，这些规范有助于提高代码的可读性和一致性。 4. **注释与程序布局** - 讲解了如何使用单行、多行注释以及Javadoc注释，以及代码的格式化和排版，良好的注释和布局对于代码的维护至关重要。 5. **类型系统** - 阐述了Java中的基本类型（如int、float等）、引用类型（类、接口、数组）以及类型转换规则，包括自动装箱拆箱和显式类型转换。 6. **变量、参数、字段和作用域** - 解释了局部变量、成员变量（字段）、方法参数的使用和作用域规则，以及它们在内存中的分配和生命周期。 7. **字符串** - Java中的String类是不可变的，这部分可能会讨论字符串的操作，如连接、子串提取、替换等，并且会提到String池的概念。 8. **数组** - 介绍了数组的创建、访问和操作，包括一维和多维数组，以及数组作为参数传递和返回值的情况。 9. **类** - 详细讲解了面向对象编程的基础，包括类的定义、继承、封装、多态性以及构造函数的使用。书中还包括了参考文献和索引，为读者提供了进一步学习和查阅的资源。这是一本适合初学者和有经验的Java开发者的技术参考书，通过严谨的论述帮助读者精确理解和掌握Java语言的每一个细节。

Chapter 7: Strings

A string is an object of the predefined class String. A string literal is a sequence of characters within

double quotes: "New York", "A38", "", and so on. Internally, a character is stored as a number using

the Unicode character encoding, whose character codes 0–127 coincide with the old ASCII character

encoding. String literals and character literals may use character escape sequences:

Escape Code Meaning

backspace

horizontal tab

newline

form feed (page break)

carriage return

the double quote character

the single quote character

the backslash character

\ddd

the character whose character code is the three-

digit octal number ddd

\udddd

the character whose character code is the four-digit

hexadecimal number dddd

A character escape sequence represents a single character. Since the letter A has code 65 (decimal),

which is written 101 in octal and 0041 in hexadecimal, the string literal "A\101\u0041" is the same as

"AAA". If s1 and s2 are expressions of type String and v is an expression of any type, then

 s1.length () of type int is the length of s1, that is, the number of characters in s1.

 s1.equals (s2) of type boolean is true if s1 and s2 contain the same sequence of

characters, and false otherwise; equalsIgnoreCase is similar but does not distinguish

lowercase and uppercase.

 s1.charAt (i) of type char is the character at position i in s1, counting from 0. If the

index i is less than 0, or greater than or equal to s1.length (), then

StringIndexOutOfBoundsException is thrown.

 s1.toString () of type String is the same object as s1.

 String.valueOf (v) returns the string representation of v, which can have any primitive

type (section 5.1

) or reference type. When v has reference type and is not null, then it is

converted using v.toString(); if it is null, then it is converted to the string "null". Any

class C inherits from Object a default toString method that produces strings of the form

C@2a5734, where 2a5734 is some memory address, but toString may be overridden to

produce more useful strings.

 s1 + s2 has the same meaning as s1.concat (s2): it constructs the concatenation of s1

and s2, a new String consisting of the characters of s1 followed by the characters of s2.

 s1 + v and v + s1 are evaluated by converting v to a string with String.valueOf (v),

thus using v.toString () when v has reference type, and then concatenating the

resulting strings.

 s1.compareTo(s2) returns a negative integer, zero, or a positive integer, according as s1

precedes, equals, or follows s2 in the usual lexicographical ordering based on the Unicode

character encoding. If s1 or s2 is null, then the exception NullPointerException is thrown.

Method compareToIgnoreCase is similar but does not distinguish lowercase and

uppercase.

 More String methods are described in the Java class library documentation [3].

Example 5: Equality of Strings, and the Subtlety of the (+) Operator

String s1 = "abc";

String s2 = s1 + ""; // New object, but contains same text as s1

String s3 = s1; // Same object as s1

Chapter 8: Arrays

An array is an indexed collection of variables, called elements. An array has a given length ℓ

≥

0 and a

given element type t. The elements are indexed by the integers 0, 1,...,ℓ - 1. The value of an

expression of array type u[] is either null or a reference to an array whose element type t is a

subtype of u. If u is a primitive type, then t must equal u.

8.1 Array Creation and Access

A new array of length ℓ with element type t is created (allocated) using an array creation expression:

new t[ℓ]

where ℓ is an expression of type int. If type t is a primitive type, all elements of the new array are

initialized to 0 (when t is byte, char, short, int, or long) or 0.0 (when t is float or double) or

false (when t is boolean). If t is a reference type, all elements are initialized to null.

If ℓ is negative, then the exception NegativeArraySizeException is thrown.

Let a be a reference of array type u[], to an array with length ℓ and element type t. Then

 a.length of type int is the length

ℓ

of a, that is, the number of elements in a.

 The array access expression a[i] denotes element number i of a, counting from 0; this

expression has type u. The integer expression i is called the array index. If the value of i

is less than 0 or greater than or equal to a.length, then exception

ArrayIndexOutOfBoundsException is thrown.

 When t is a reference type, every array element assignment a[i] = e checks that the

value of e is null or a reference to an object whose class C is a subtype of the element

type t. If this is not the case, then the exception ArrayStoreException is thrown. This

check is made before every array element assignment at run-time, but only for reference

types.

8.2 Array Initializers

A variable or field of array type may be initialized at declaration, using an existing array or an array

initializer for the initial value. An array initializer is a comma-separated list of zero or more expressions

enclosed in braces { ... }:

t[] x = { expression, ..., expression }

The type of each expression must be a subtype of t. Evaluation of the initializer causes a distinct new

array, whose length equals the number of expressions, to be allocated. Then the expressions are

evaluated from left to right and their values are stored in the array, and finally the array is bound to x.

Hence x cannot occur in the expressions: it has not been initialized when they are evaluated.

Array initializers may also be used in connection with array creation expressions:

new t[] { expression, ..., expression }

Multidimensional arrays can have nested initializers (example 14

). Note that there are no array

constants: a new distinct array is created every time an array initializer is evaluated.

Example 10: Creating and Using One-Dimensional Arrays

The first half of this example rolls a die one thousand times, then prints the frequencies of the outcomes.

The second half creates and initializes an array of String objects.

int[] freq = new int[6]; // All initialized to 0

for (int i=0; i<1000; i++) { // Roll dice, count frequencies

int die = (int) (1 + 6 * Math.random());

freq[die-1] += 1;

}

for (int c=1; c<=6; c++)

System.out.println(c + " came up " + freq[c-1] + " times");

String[] number = new String[20]; // Create array of null elements

for (int i=0; i<number.length; i++) // Fill with strings "A0", ..., "A19"

number[i] "A" + i;

for (int i=0; i<number.length; i++) // Print strings

System.out.println(number[i]);

Example 11: Array Element Assignment Type Check at Run-Time

This program compiles, but at run-time a[2] =d throws ArrayStoreException, since the class of the object

bound to d (that is, Double) is not a subtype of a's element type (that is, Integer).

Number[] a = new Integer[10]; // Length 10, element type Integer

Double d = new Double(3.14); // Type Double, class Double

Integer i = new Integer(117); // Type Integer, class Integer

Number n = i; // Type Number, class Integer

a[0] = i; // OK, Integer is subtype of Integer

a[1] = n; // OK, Integer is subtype of Integer

a[2] = d; // No, Double not subtype of Integer

Example 12: Using an Initialized Array

Method checkdate here behaves the same as checkdate in example 2

. The array should be declared

outside the method, otherwise a distinct new array is created for every call to the method.

static int[] days = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };

static boolean checkdate(int mth, int day)

{ return (mth >= 1) && (mth <= 12) && (day >= 1) && (day <= days[mth-1]); }

Example 13: Creating a String from a Character Array

When replacing character cl by character c2 in a string, the result can be built in a character array

because its length is known. This is 50 percent faster than example 85

which uses a string buffer.

static String replaceCharChar(String s, char cl, char c2) {

char[] res = new char[s.length()];

for (int i=0; i<s.length(); i++)

if (s.charAt(i) == cl)

res [i] = c2;

else

res[i] = s.charAt(i);

return new String(res); // A string containing the characters of res

}

8.3 Multidimensional Arrays

The types of multidimensional arrays are written t[] [], t[] [] [], and so on. A rectangular n-

dimensional array of size ℓ

ℓ

...

ℓ

is created (allocated) using the array creation expression

new t[ℓ

] [ℓ

] ... [ℓ

]

A multidimensional array a of type t[] [] is in fact a one-dimensional array of arrays; its component

arrays have type t[]. Hence a multidimensional array need not be rectangular, and one need not

create all the dimensions at once. To create only the first k dimensions of size ℓ

ℓ

...

ℓ

of an n-

dimensional array, leave the (n

–

k) last brackets empty:

new t[ℓ

] [ℓ

] ... [ℓ

] [] ... []

To access an element of an n-dimensional array a, use n index expressions: a[i

] [i

] ... [i

剩余118页未读，继续阅读

ctchen1990

粉丝: 0
资源: 1

Java编程精要：MIT出版社

Java Precisely, 2nd edition

C# Precisely (MIT Press)

java-precisely-3rd.rar

java_precisely

python-precisely:适用于Python的Matcher库

precisely-map:这是检查DAT AON单击事件的地图

4147 of CEF. precisely, CEF 84.3.8 which includes Chromium 支持MP4

precisely:一个R包，用于根据精度而不是功效来估计样本大小

精准估计样本量：R包'precisely'使用精度方法

Java编程精要

最新资源