Java精要第二版：权威指南

5星 · 超过95%的资源需积分: 9 109 浏览量更新于2024-07-28 1 收藏 26.9MB PDF 举报

"Java Precisely, 2nd edition 是一本由Peter Sestoft编写的关于Java编程语言的详细教程，强调了精准和简洁性，适合初学者和有经验的开发者参考。这本书由MIT Press出版，旨在深入理解Java的核心概念和技术。" 在《Java Precisely》第二版中，作者Peter Sestoft深入浅出地介绍了Java语言的关键知识点。这本书不仅仅是对Java语法的简单介绍，更是对Java编程思想的精确阐述，使得读者能够精确地理解和运用Java语言。以下是书中可能涵盖的一些核心内容： 1. **Java环境设置与运行**：书中可能详细介绍了如何配置Java开发环境，包括安装JDK、设置环境变量以及如何运行一个简单的Java程序，帮助读者快速上手。 2. **基础语法**：涵盖Java的基本数据类型、变量、运算符、控制流程（如if语句、循环）以及方法的定义和调用，这些都是编程的基础。 3. **类与对象**：Java是面向对象的语言，书中会讲解类的定义、对象的创建与销毁，以及封装、继承和多态等面向对象的特性。 4. **异常处理**：Java中的异常处理机制是其独特之处，书中可能会详细介绍如何使用try-catch-finally语句块来捕获和处理异常。 5. **数组与集合**：书中会介绍数组的使用，以及更灵活的集合框架，如List、Set和Map接口，以及它们的实现类如ArrayList、HashSet和HashMap等。 6. **IO流与NIO**：Java的输入输出系统是编程中不可或缺的部分，书中会讲解如何进行文件操作，以及非阻塞I/O（NIO）的概念。 7. **多线程**：Java提供了内置的多线程支持，书中会讨论线程的创建、同步和通信，包括synchronized关键字、wait()、notify()方法等。 8. **反射与注解**：反射允许程序在运行时检查和修改自身，注解则提供了一种元数据，书中会讲解这两者的使用和重要性。 9. **泛型**：Java泛型提高了代码的类型安全性，书中会详细解释泛型的定义、使用及限制。 10. **Java内存管理与垃圾收集**：这部分内容会涉及Java的内存模型，如何分配和回收内存，以及垃圾收集的工作原理。 11. **模块化系统（Java 9及以上）**：随着Java版本的更新，模块化系统（Project Jigsaw）被引入，书中会讲解如何使用模块化来组织和打包代码。 12. **Java标准库**：书中会介绍一些常用的Java标准库，如集合框架、网络编程、日期时间API等。 13. **测试与调试**：Java编程中测试和调试的重要性不言而喻，书中可能会包含JUnit的使用和其他调试技巧。 14. **编译与部署**：讲解如何编译Java源码成字节码，以及打包成JAR文件或应用服务器部署的相关知识。 15. **性能优化**：书中可能包含一些性能优化的建议和实践，如避免不必要的对象创建、使用StringBuilder代替String连接等。此外，书中的实例和练习将帮助读者巩固所学知识，并提高实际编程能力。书后附有详细的参考文献和索引，方便读者查阅相关资料。《Java Precisely, 2nd edition》是一本全面而精确的Java教程，它不仅适合初学者入门，也对有经验的开发者在深入理解Java语言的细节和最佳实践方面有着重要的参考价值。

Comments and Program Layout

Example 1

Comments

class Comment f

// This is a one-line comment; it extends to the end of the line.

/* This is a delimited comment,

extending over several lines.

int /* This delimited comment extends over part of a line */ x = 117;

Example 2

Recommended Program Layout Style

For reasons of space this layout style is not always followed in this book.

class Layout {



// Class declaration

int x;

Layout(int x) f

this.x = x;

int sum(int y) {

if (x > 0) {

return x + y;

} else if (x < 0)

int res = -x + y;

return res * 117;

else { // x == 0

int sum = 0;

for (int i=0; i<10; i++) f

sum += (y - i) * (y - i);

return sum;

// One-line body

Multi-line body

// If statement

// Single statement

// Nested if-else, block statement

// Terminal else, block statement

// For loop

static boolean checkdate(int mth, int day) {

int length;

switch (mth) {



// Switch statement

case 2:



// Single case

length = 28; break;

case 4: case 6: case 9: case 11:



// Multiple case

length = 30; break;

case 1: case 3: case 5: case 7: case 8: case 10: case 12:

length = 31; break;

default:

return false;

return (day >= 1) && (day <= length);

Types

5 Types

type

is a

set of values and operations on them. A type is either a primitive type or a reference type.

5.1 Primitive Types

primitive type

is either boolean or one of the

numeric types

char, byte, short, int, long, float, and

double. The primitive types, example literals (that is, constants), size in bits (where 8 bits equals 1 byte), and

value range, are shown in the table opposite.

The integer types are exact within their range. They use signed 2's complement representation (except

for char), so when the most positive number in a type is

max,

then the most negative number is

—max —

The floating-point types are inexact and follow tEEE754, with the number of significant digits indicated by

"sigdig." For character escape sequences such as

\ u0 0 0 0,

see page 10.

5.2 Reference Types

reference type

is either a class type defined by a class declaration (section 9.1), or an interface type defined

by an interface declaration (section 13.1), or an array type (section 5.3), or an enum type (section 14).

A value of reference type is either null or a reference to an object or array. The special value null denotes

"no object." The literal null, denoting the null value, can have any reference type.

5.3 Array Types

array type

has the form t [1, where t is any type. An array type t [1 is a reference type. Hence a value

of array type t [1 is either null, or is a reference to an array whose element type is precisely t (when t is a

primitive type), or is a subtype of t (when t is a reference type).

5.4 Boxing: Wrapping Primitive Types As Reference Types

For every primitive type there is a corresponding wrapper class, which is a reference type. The wrapper classes

are listed in the table opposite. An object of a wrapper class contains a single value of the corresponding

primitive type.

A wrapper class must be used when a value of primitive type is passed to a method that expects a reference

type, or stored in a variable or field of reference type. For instance, to store an

int

in a collection (section 22)

one must wrap it as an Integer object.

The conversion from primitive type to wrapper class is called

boxing,

and the opposite conversion is called

unboxing.

Boxing and unboxing are performed automatically (in Java 5.0) when needed. Boxing and un-

boxing may also be performed explicitly using operations such as

new Integer (i)

to box the integer

and

o . int Value 0 or ( int )

to unbox the Integer object

o is null,

then unboxing of

will fail at run-time

by throwing NullPointerException. Because of automatic unboxing, a Boolean value may be used in condi-

tional statements

(if, for, while

and

while)

and in logical operators (such as ! ,

? :

and so on); and

Integer and other integer type wrapper classes may be used in swit

ch statements.

boxed value can be unboxed only to a value of the boxed type, or to a supertype. Thus an Integer object

can be unboxed to an int or a

long because long is a supertype of int,

but not to a

char or byte or short.

The wrapper classes Byte, Short, Integer, Long, Float, and Double have the common superclass Number.

Primitive Types

Types

Type



Kind

Example Literals

Size



Range

Wrapper

boolean



logical

false, true

Boolean

char



integer



'0',



'A',



\u0000



\uFFFF (unsigned)



Character

byte



integer

0, 1, -1, 117, ...

max = 127



Byte

short



integer

0, 1, -1, 117, ...

max = 32767



Short

int



integer

0, 1, -1, 117, ...

max = 2147483647



Integer

long



integer

OL, 1L, -1L, 117L,

max = 9223372036854775807



Long

float



floating-pt

-1.0f, 0.49f, 3E8f, ...

±10-38



1038, sigdig 6-7



Float

double



floating-pt

-1.0, 0.49, 3E8, ...

±10-308... ± 10308, sigdig 15-16



Double

Integer Literals

Integer literals (of type byte, char, short, int, or long) may be written in three different bases.

Notation

Base



Distinction

Example Integer Literals

Decimal



No leading

1234567890, 127, -127

Octal



Leading

01234567, 0177, -0177

Hexadecimal



Leading Ox

OxABCDEF0123, Ox7F, -0x7F

Example 3

Automatic Boxing and Unboxing

Boolean bbl = false, bb2 =



!bbl;



Boxing to

[false]



[true]

Integer bil =

117;



Boxing to

[117]

Double bdl = 1.2;



Boxing to

[1.2]

boolean bl = bbl;



(bbl)



Unboxing,

result false

System.out.println("Not true");

int it = bil + 2;



Unboxing, result 119

// short s = bil;



Illegal

long 1 = bil;



Legal: int is subtype of long

Integer bi2 = bil + 2;



Unboxing, boxing,



result



[119]

Integer[] biarr = { 2, 3, 5, 7, 11 };

int sum = 0;

for (Integer bi : biarr)

sum += bi;



// Unboxing in loop body

for (int i : biarr)



// Unboxing in loop header

sum += i;

int i = 1934;

Integer bi4 = i, bi5 = i;

// Prints true true true false; bi4==bi5 is a reference comparison:

System.out.format("%b %b %b %b%n", i==i, bi4==i, i==bi5, bi4==bi5);

Boolean bbn = null;

boolean b = bbn;



// Compiles OK, fails at run-time

if (bbn)



// Compiles OK, fails at run-time

System.out.println("Not true");

Integer bin = null;

Integer bi6 = bin + 2;



// Compiles OK, fails at run-time

Types

5.5 Subtypes and Compatibility

A type t1 may be a

subtype

of a type

t2,

in which case t2 is a

supertype

of t1. Intuitively this means that any

value

of type t1 can be used where a value of type t2 is expected. When t1 and t2 are reference types,

t1 must provide at least the functionality (methods and fields) provided by

t2.

In particular, any value

type t

may be bound to a variable or field or parameter x2 of type t2, e.g., by the assignment x2 =

or by

parameter passing. We also say that types t1 and t2 are

compatible.

The following rules determine when a

type t

is a subtype of a type

t2:

•

Every type is a subtype of itself.

•

If t

is a subtype of t2, and t2 is a subtype of t3, then t

is a subtype of

t3.

•

If t1 and t2 are primitive types, and there is a widening (W or L) conversion from

to t2 according

to the table opposite, then t1 is a subtype of t2.

•

If t1 and t2 are classes, then t1 is a subtype of t2 if t1 is a subclass of t2.

•

If tl and t2 are interfaces, then Li is a subtype of t2 if t1

a subinterface of

t2.

•

If t1 is a class and t2 is an interface, then t

is a subtype of t2 provided that t1 (is a subclass of a class

that) implements t2 or implements a subinterface of t2.

•

Array type t 1 E is a subtype of array type t2

[]

if reference type t 1 is a subtype of reference type t2.

•

Any reference type t, including any array type, is also a subtype of predefined class Object.

No primitive type is a subtype of a reference type and no reference type is a subtype of a primitive type.

But there are automatic boxing and unboxing conversions between a primitive type and its wrapper class; see

section 5.4.

5.6 Signatures and Subsumption

signature

has form m(t ,



, t

), where

is a method or constructor name, and (t



, t

) is a list of

non-generic types; see example

33.

We say that a signature

sigi = m(t 1,



)

subsumes

signature

sig

= m(u



, li

)

if each u

is a subtype

of ti. We also say that

sig2 is more specific

than

sigi.

Note that the method name

and the number

of types

must be the same in the two signatures. Since every type ti is a subtype of itself, every signature subsumes

itself. In a collection of signatures there may be one that is subsumed by all others; such a signature is called

the

most specific

signature.

5.7 Type Conversion

type conversion

converts a value from one type to another. A

widening

conversion converts from a type to

a supertype (or the type itself). A

narrowing

conversion converts from a type to another type. A narrowing

conversion requires an explicit

type cast,

see section 11.11, except in an assignment x = e or initialization

where e is a compile-time integer constant; see section 11.5.

The legal type conversions between primitive types are shown in the table opposite. The primitive type

boolean cannot be converted to any other primitive type. A type cast between primitive types never fails at

run-time.

Types 7

Conversion between Primitive Types

The letter C marks a narrowing conversion that requires a type cast ( t) e, see section 11.11; W marks a

widening conversion that preserves the value; and

marks a widening conversion that may cause a loss of

precision. A narrowing integer conversion discards those (most significant) bits that cannot be represented in

the smaller integer type. Conversion from an integer type to a floating-point type (float or

double)

produces

a floating-point approximation of the integer value. Conversion from a floating-point type to an integer type

discards the fractional part of the number; that is, it rounds toward zero. When converting a too-large floating-

point number to a

long

or int, the result is the best approximation (that is, the type's largest positive or the

largest negative representable number); conversion to

byte

short

char

is done by converting to int and

then to the requested type.

From Type

To Type

char

byte

short

int

long

oat

double

char

C C

W W W

byte

W W W

short

W W

int

C C

long

C C

float

C C

double

C C C

Example 4

Conversion between Primitive Types

This example shows lossy (L) and lossless (W) widening conversions to float and

double

as well as narrow-

ing conversions (C) from int and double. Example 48 shows primitive conversions in assignments.

private static void floatdouble(float f, double d)

{ System.out.println(f + " " + d); }

private static void bytecharshort(byte b, char c, short s)

{ System.out.println(b + " " + (int)c + " " + s); 1

private static void intint(int il, int i2)

{ System.out.println(il + " " + i2); }

int il = 1000111222, i2 = 40000, i3 = -1;

floatdouble(il, il);

bytecharshort((byte)i2, (char)i2, (short)i2);

bytecharshort((byte)i3, (char)i3, (short)i3);

intint((int)1.9, (int)-1.9);

intint((int)1.5, (int)-1.5);

intint((int)2.5, (int)-2.5);

L W:

1.00011123E9



1.000111222E9

C C

40000

-25536

C C

-1

65535

-1

C C:

-1

C C:

-1

C C:

-2

Example 5

Method Signature Subsumption

•

m (double , double)

subsumes itself and

m (double , int )

and m ( int ,

double)

and m (

int , int ) .

•

m (double , int)

subsumes itself and m (

int , int ) .

•

m ( int , double)

subsumes itself and m (

int , int ) .

•

m (double, int )

does not subsume

m ( int , double) ,

nor the other way round.

•

The collection

m (double , int) , m ( int , int)

has the most specific signature

m ( int , int) .

•

The collection

m (double , int) , m ( int , double)

has no most specific signature.

剩余169页未读，继续阅读

ralphsage

粉丝: 27
资源: 96

Java精要第二版：权威指南

《Java Precisely》：深入解析Java编程语言

Java编程参考书籍《Precisely》第三版精华解析

Java编程精要：英文版PDF解读

java_precisely

java-precisely-3rd.rar

C# Precisely (MIT Press)

python-precisely:适用于Python的Matcher库

Higher Engineering Mathematics 5th Edition

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

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

最新资源