Core Java Volume I - 8th Edition: Essentials for Programmers

需积分: 12 43 浏览量更新于2024-07-27 收藏 18.53MB PDF 举报

"Core Java. Volume I. Fundamentals, 8th Edition" 《Core Java. Volume I. Fundamentals, 8th Edition》是一本专为Java编程初学者和专业人士设计的权威指南，它全面覆盖了Java语言的基础知识。本书是第八版，由Cay S. Horstmann和Gary Cornell合著，旨在帮助读者深入理解Java编程的核心概念。在这一版中，作者们对Java的最新发展，特别是Java 8的特性进行了详细介绍。Java 8是Java语言的一个重要里程碑，引入了lambda表达式、函数式编程概念、流API（Stream API）以及日期/时间API等新特性，极大地提高了代码的简洁性和效率。通过学习这本书，读者可以了解到如何利用这些新特性来编写更加高效、可维护的代码。本书涵盖了以下几个关键知识点： 1. **基础语法**：从Java的安装配置开始，讲解基本的编程概念，如数据类型、变量、运算符、流程控制（if、switch、for、while）、方法定义和调用，以及数组的使用。 2. **类和对象**：深入探讨面向对象编程，包括类的定义、对象的创建、封装、继承、多态性，以及接口的概念。 3. **异常处理**：讲解Java中的异常模型，如何抛出和捕获异常，以及如何编写健壮的异常处理代码。 4. **集合框架**：详细阐述ArrayList、LinkedList、HashSet、HashMap等集合类的使用，以及集合接口和泛型的理解。 5. **输入/输出(I/O)**：涵盖文件操作、字节流、字符流、缓冲区流、对象序列化等内容，使读者能够进行有效的文件读写和数据交换。 6. **多线程**：介绍线程的基本概念，如何创建和管理线程，同步机制（synchronized关键字、wait()、notify()），以及线程池的使用。 7. **字符串处理**：讲解String类的特性，以及StringBuilder和StringBuffer的使用，强调字符串操作的效率问题。 8. **枚举和注解**：介绍枚举类型和注解的用途，以及它们在实际编程中的应用。 9. **Lambda表达式和函数式编程**：重点讲解Java 8引入的新特性，如何使用lambda表达式简化代码，以及如何利用函数式接口和Stream API进行数据处理。 10. **日期和时间API**：解释新的日期/时间API，如LocalDate、LocalTime、LocalDateTime等，替代了原有的Calendar和Date类。本书不仅适合初学者作为入门教材，也适用于有一定经验的开发者作为参考书籍，以更新他们的Java知识，尤其是对Java 8新特性的掌握。书中包含丰富的示例代码和实践练习，有助于读者巩固理论知识并提升实际编程能力。通过系统学习，读者将能够熟练地运用Java进行软件开发，并为进一步学习Java高级特性及框架打下坚实的基础。

Chapter 1

■

An Introduction to Java

he first release of Java in 1996 generated an incredible amount of excitement, not

just in the computer press, but in mainstream media such as The New York Times, The

Washington Post, and Business Week. Java has the distinction of being the first and only

programming language that had a ten-minute story on National Public Radio. A

$100,000,000 venture capital fund was set up solely for products produced by use of a

specific computer language. It is rather amusing to revisit those heady times, and we

give you a brief history of Java in this chapter.

Java As a Programming Platform

In the first edition of this book, we had this to write about Java:

“As a computer language, Java’s hype is overdone: Java is certainly a good program-

ming language. There is no doubt that it is one of the better languages available to

serious programmers. We think it could potentially have been a great programming

language, but it is probably too late for that. Once a language is out in the field, the ugly

reality of compatibility with existing code sets in.”

Our editor got a lot of flack for this paragraph from someone very high up at Sun Micro-

systems who shall remain unnamed. But, in hindsight, our prognosis seems accurate.

Java has a lot of nice language features—we examine them in detail later in this chapter.

It has its share of warts, and newer additions to the language are not as elegant as the

original ones because of the ugly reality of compatibility.

But, as we already said in the first edition, Java was never just a language. There are lots

of programming languages out there, and few of them make much of a splash. Java is a

whole platform, with a huge library, containing lots of reusable code, and an execution

environment that provides services such as security, portability across operating sys-

tems, and automatic garbage collection.

As a programmer, you will want a language with a pleasant syntax and comprehensible

semantics (i.e., not C++). Java fits the bill, as do dozens of other fine languages. Some

languages give you portability, garbage collection, and the like, but they don’t have

much of a library, forcing you to roll your own if you want fancy graphics or network-

ing or database access. Well, Java has everything—a good language, a high-quality exe-

cution environment, and a vast library. That combination is what makes Java an

irresistible proposition to so many programmers.

The Java “White Paper” Buzzwords

The authors of Java have written an influential White Paper that explains their design

goals and accomplishments. They also published a shorter summary that is organized

along the following 11 buzzwords:

Simple Portable

Object Oriented Interpreted

Network-Savvy High Performance

Robust Multithreaded

Secure Dynamic

Architecture Neutral

Chapter 1. An Introduction to Java

The Java “White Paper” Buzzwords

In this section, we will

• Summarize, with excerpts from the White Paper, what the Java designers say about

each buzzword; and

• Tell you what we think of each buzzword, based on our experiences with the cur-

rent version of Java.

NOTE: As we write this, the White Paper can be found at http://java.sun.com/docs/white/

langenv/. The summary with the 11 buzzwords is at http://java.sun.com/docs/overviews/java/

java-overview-1.html.

Simple

We wanted to build a system that could be programmed easily without a lot of eso-

teric training and which leveraged today’s standard practice. So even though we

found that C++ was unsuitable, we designed Java as closely to C++ as possible in

order to make the system more comprehensible. Java omits many rarely used, poorly

understood, confusing features of C++ that, in our experience, bring more grief

than benefit.

The syntax for Java is, indeed, a cleaned-up version of the syntax for C++. There is no

need for header files, pointer arithmetic (or even a pointer syntax), structures, unions,

operator overloading, virtual base classes, and so on. (See the C++ notes interspersed

throughout the text for more on the differences between Java and C++.) The designers

did not, however, attempt to fix all of the clumsy features of C++. For example, the syn-

tax of the

switch

statement is unchanged in Java. If you know C++, you will find the tran-

sition to the Java syntax easy.

If you are used to a visual programming environment (such as Visual Basic), you will

not find Java simple. There is much strange syntax (though it does not take long to get

the hang of it). More important, you must do a lot more programming in Java. The

beauty of Visual Basic is that its visual design environment almost automatically pro-

vides a lot of the infrastructure for an application. The equivalent functionality must be

programmed manually, usually with a fair bit of code, in Java. There are, however,

third-party development environments that provide “drag-and-drop”-style program

development.

Another aspect of being simple is being small. One of the goals of Java is to enable

the construction of software that can run stand-alone in small machines. The size of

the basic interpreter and class support is about 40K bytes; adding the basic stan-

dard libraries and thread support (essentially a self-contained microkernel) adds an

additional 175K.

This was a great achievement at the time. Of course, the library has since grown to huge

proportions. There is now a separate Java Micro Edition with a smaller library, suitable

for embedded devices.

Object Oriented

Simply stated, object-oriented design is a technique for programming that focuses

on the data (= objects) and on the interfaces to that object. To make an analogy with

carpentry, an “object-oriented” carpenter would be mostly concerned with the chair

Chapter 1. An Introduction to Java

Chapter 1

■

An Introduction to Java

he was building, and secondarily with the tools used to make it; a “non-object-

oriented” carpenter would think primarily of his tools. The object-oriented facilities

of Java are essentially those of C++.

Object orientation has proven its worth in the last 30 years, and it is inconceivable that a

modern programming language would not use it. Indeed, the object-oriented features of

Java are comparable to those of C++. The major difference between Java and C++ lies in

multiple inheritance, which Java has replaced with the simpler concept of interfaces,

and in the Java metaclass model (which we discuss in Chapter 5).

NOTE: If you have no experience with object-oriented programming languages, you will

want to carefully read Chapters 4 through 6. These chapters explain what object-oriented

programming is and why it is more useful for programming sophisticated projects than are

traditional, procedure-oriented languages like C or Basic.

Network-Savvy

Java has an extensive library of routines for coping with TCP/IP protocols like

HTTP and FTP. Java applications can open and access objects across the Net via

URLs with the same ease as when accessing a local file system.

We have found the networking capabilities of Java to be both strong and easy to use.

Anyone who has tried to do Internet programming using another language will revel in

how simple Java makes onerous tasks like opening a socket connection. (We cover net-

working in Volume II of this book.) The remote method invocation mechanism enables

communication between distributed objects (also covered in Volume II).

Robust

Java is intended for writing programs that must be reliable in a variety of ways.

Java puts a lot of emphasis on early checking for possible problems, later dynamic

(runtime) checking, and eliminating situations that are error-prone. . . . The single

biggest difference between Java and C/C++ is that Java has a pointer model that elim-

inates the possibility of overwriting memory and corrupting data.

This feature is also very useful. The Java compiler detects many problems that, in other

languages, would show up only at runtime. As for the second point, anyone who has

spent hours chasing memory corruption caused by a pointer bug will be very happy

with this feature of Java.

If you are coming from a language like Visual Basic that doesn’t explicitly use pointers,

you are probably wondering why this is so important. C programmers are not so lucky.

They need pointers to access strings, arrays, objects, and even files. In Visual Basic, you

do not use pointers for any of these entities, nor do you need to worry about memory

allocation for them. On the other hand, many data structures are difficult to implement

in a pointerless language. Java gives you the best of both worlds. You do not need point-

ers for everyday constructs like strings and arrays. You have the power of pointers if

you need it, for example, for linked lists. And you always have complete safety, because

you can never access a bad pointer, make memory allocation errors, or have to protect

against memory leaking away.

Chapter 1. An Introduction to Java

The Java “White Paper” Buzzwords

Secure

Java is intended to be used in networked/distributed environments. Toward that

end, a lot of emphasis has been placed on security. Java enables the construction of

virus-free, tamper-free systems.

In the first edition of Core Java we said: “Well, one should ‘never say never again,’” and

we turned out to be right. Not long after the first version of the Java Development Kit

was shipped, a group of security experts at Princeton University found subtle bugs in

the security features of Java 1.0. Sun Microsystems has encouraged research into Java

security, making publicly available the specification and implementation of the virtual

machine and the security libraries. They have fixed all known security bugs quickly. In

any case, Java makes it extremely difficult to outwit its security mechanisms. The bugs

found so far have been very technical and few in number.

From the beginning, Java was designed to make certain kinds of attacks impossible,

among them:

• Overrunning the runtime stack—a common attack of worms and viruses

• Corrupting memory outside its own process space

• Reading or writing files without permission

A number of security features have been added to Java over time. Since version 1.1, Java

has the notion of digitally signed classes (see Volume II). With a signed class, you can be

sure who wrote it. Any time you trust the author of the class, the class can be allowed

more privileges on your machine.

NOTE: A competing code delivery mechanism from Microsoft based on its ActiveX technol-

ogy relies on digital signatures alone for security. Clearly this is not sufficient—as any user

of Microsoft’s own products can confirm, programs from well-known vendors do crash and

create damage. Java has a far stronger security model than that of ActiveX because it con-

trols the application as it runs and stops it from wreaking havoc.

Architecture Neutral

The compiler generates an architecture-neutral object file format—the compiled

code is executable on many processors, given the presence of the Java runtime sys-

tem. The Java compiler does this by generating bytecode instructions which have

nothing to do with a particular computer architecture. Rather, they are designed to

be both easy to interpret on any machine and easily translated into native machine

code on the fly.

This is not a new idea. More than 30 years ago, both Niklaus Wirth’s original implemen-

tation of Pascal and the UCSD Pascal system used the same technique.

Of course, interpreting bytecodes is necessarily slower than running machine instruc-

tions at full speed, so it isn’t clear that this is even a good idea. However, virtual

machines have the option of translating the most frequently executed bytecode

sequences into machine code, a process called just-in-time compilation. This strategy

has proven so effective that even Microsoft’s .NET platform relies on a virtual machine.

Chapter 1. An Introduction to Java

Chapter 1

■

An Introduction to Java

The virtual machine has other advantages. It increases security because the virtual

machine can check the behavior of instruction sequences. Some programs even produce

bytecodes on the fly, dynamically enhancing the capabilities of a running program.

Portable

Unlike C and C++, there are no “implementation-dependent” aspects of the specifi-

cation. The sizes of the primitive data types are specified, as is the behavior of arith-

metic on them.

For example, an

int

in Java is always a 32-bit integer. In C/C++,

int

can mean a 16-bit

integer, a 32-bit integer, or any other size that the compiler vendor likes. The only

restriction is that the

int

type must have at least as many bytes as a

short int

and cannot

have more bytes than a

long int

. Having a fixed size for number types eliminates a major

porting headache. Binary data is stored and transmitted in a fixed format, eliminating

confusion about byte ordering. Strings are saved in a standard Unicode format.

The libraries that are a part of the system define portable interfaces. For example,

there is an abstract Window class and implementations of it for UNIX, Windows,

and the Macintosh.

As anyone who has ever tried knows, it is an effort of heroic proportions to write a pro-

gram that looks good on Windows, the Macintosh, and ten flavors of UNIX. Java 1.0

made the heroic effort, delivering a simple toolkit that mapped common user interface

elements to a number of platforms. Unfortunately, the result was a library that, with a

lot of work, could give barely acceptable results on different systems. (And there were

often different bugs on the different platform graphics implementations.) But it was a

start. There are many applications in which portability is more important than user

interface slickness, and these applications did benefit from early versions of Java. By

now, the user interface toolkit has been completely rewritten so that it no longer relies

on the host user interface. The result is far more consistent and, we think, more attrac-

tive than in earlier versions of Java.

Interpreted

The Java interpreter can execute Java bytecodes directly on any machine to which

the interpreter has been ported. Since linking is a more incremental and lightweight

process, the development process can be much more rapid and exploratory.

Incremental linking has advantages, but its benefit for the development process is

clearly overstated. Early Java development tools were, in fact, quite slow. Today, the

bytecodes are translated into machine code by the just-in-time compiler.

High Performance

While the performance of interpreted bytecodes is usually more than adequate,

there are situations where higher performance is required. The bytecodes can be

translated on the fly (at runtime) into machine code for the particular CPU the

application is running on.

In the early years of Java, many users disagreed with the statement that the perfor-

mance was “more than adequate.” Today, however, the just-in-time compilers have

become so good that they are competitive with traditional compilers and, in some cases,

even outperform them because they have more information available. For example, a

just-in-time compiler can monitor which code is executed frequently and optimize just

Chapter 1. An Introduction to Java

剩余824页未读，继续阅读

ikaraide

粉丝: 2
资源: 9

Core Java Volume I - 8th Edition: Essentials for Programmers

Java 核心技术 第八版-第1卷+源代码【Core Java. Volume I. Fundamentals, 8th Edition】

Core Java. Volume I. Fundamentals, 8th Edition.pdf

Core Java. Volume I. Fundamentals, 8th Edition.part2.rar

core java, volume i: fundamentals, 12e

关于Java的外文期刊参考文献

2021年至2023年出版的Java类书籍

使用get_fundamentals获取股票SHSE.600000，在2022年一整年资产负债表，CURFDS（货币资金）, SETTRESEDEPO（结算备付金）, PLAC（拆出资金）, TRADFINASSET（交易性金融资产）, DERIFINAASSET（衍生金融资产）等财务字段的数据。

C语言与循环有关的英语文献并且以英文参考文献引用格式发给我

在恒定电位下，如果电流密度随时间的增加而线性增加，则说明腐蚀反应是受活化控制；如果电流密度呈现出指数形式的增加，则说明腐蚀反应是受扩散控制。以上描述的相关参考文献有哪些?

有关 线性码 的 参考文献

最新资源

Java 核心技术第八版-第1卷+源代码【Core Java. Volume I. Fundamentals, 8th Edition】

有关线性码的参考文献