University of Illinois Java编程教程

需积分: 10 74 浏览量更新于2024-07-27 收藏 5.41MB PDF 举报

"这是一份由伊利诺伊大学教授编写的《使用Java进行程序设计》教程，版本5.0，2006年12月发布，稍后在2010年12月进行了小幅度更新和修正。作者David J. Eck是霍巴特和威廉史密斯学院的教授，该教程在线版本可在http://math.hws.edu/javanotes/找到。PDF版不包含源代码文件、练习答案和测验答案，但提供了指向这些资源的外部链接（显示为蓝色）。每个章节也有链接到在线版本（显示为红色），并具有内部链接功能，适用于 Acrobat Reader 和某些其他PDF阅读器程序。该书的版权遵循 Creative Commons Attribution-ShareAlike 2.5 License，允许无修改的自由分发，修改后的版本也需在相同的许可下分发。" 这份Java教程是初学者入门编程的理想选择，它由知名大学的教授编写，因此具有权威性和深度。教程内容可能涵盖了Java语言的基础知识，包括但不限于变量、数据类型、控制结构（如if语句和循环）、函数、类与对象、继承、多态性等核心概念。此外，由于是大学内部资料，可能还会涉及一些更高级的主题，如异常处理、文件操作、集合框架、线程和网络编程。教程分为多个章节，每个章节都设计有练习题和测验，以帮助学习者巩固所学知识，并鼓励他们实际操作和解决问题。尽管PDF版本没有提供源代码文件，但在线版本可能包含了这些实践性的部分，这对于学习编程语言至关重要，因为实践是掌握编程技能的关键。此外，教程采用Creative Commons Attribution-ShareAlike 2.5 License授权，意味着任何人都可以自由地分享、复制、修改这本书，只要保留原作者的署名，并且如果修改了内容，必须同样使用相同的许可协议发布。这种开放的许可方式促进了知识的共享和传播。这份Java教程是学习Java编程的一个宝贵资源，无论是对初次接触编程的学生还是想要复习基础的开发者，都能从中受益。通过阅读、实践和理解其中的概念，学习者可以建立起坚实的Java编程基础，为进一步深入学习Java和相关技术铺平道路。

CHAPTER 1. THE MENTAL LANDSCAPE 2

location. The CPU can also store information in memory by specifying the information to be

stored and the ad dress of the location where it is to be stored.

On the level of machine language, the operation of the CPU is fairly straightforward (al-

though it is very complicated in d etail). The CPU executes a program that is stored as a

sequence of machine language instructions in main memory. It does this by repeatedly reading,

or fetching, an instruction from memory an d then carrying out, or executing, that instruc-

tion. This process—fetch an instruction, execute it, fetch another instruction, execute it, and so

on forever—is called the fetch-and- execute cycle. With one exception, which will be covered

in the next section, this is all th at the CPU ever does.

The details of the fetch-and-execute cycle are not terribly important, but there are a few

basic things you should know. The CPU contains a few internal registers, which are small

memory units capable of holding a single number or machine language instruction. The CPU

uses one of these registers—the p rogram counter , or PC—to keep track of where it is in the

program it is executing. The PC stores the address of the next in s tr uction that the CPU should

execute. At the beginning of each fetch-and-execute cycle, the CPU checks the PC to see which

instruction it should fetch. During the course of the fetch-and-execute cycle, the number in the

PC is updated to indicate the instruction that is to be executed in the n ext cycle. (Usually,

but not always, this is just the instruction that sequentially follows th e current instruction in

the program.)

∗ ∗ ∗

A computer executes machine language p rograms mechanically—that is without under-

standing them or thinking about them—simply because of the way it is physically put together.

This is not an easy concept. A computer is a machine built of millions of tiny switches called

transistors, which have the property that they can be wired together in such a way that an

output from one switch can turn another switch on or oﬀ. As a computer computes, these

switches turn each other on or oﬀ in a pattern determined both by the way they are wired

together an d by the program that th e computer is executing.

Machine language instructions are expressed as b inary numbers. A binary number is made

up of jus t two possible digits, zero and one. So, a machine language instruction is just a sequence

of zeros and ones. Each particular sequence encodes some particular instruction. The data that

the computer manipu lates is also encoded as binary numbers. A computer can work directly

with binary numbers because switches can readily represent such numbers: Turn the switch on

to represent a one; turn it oﬀ to represent a zero. Machine language ins tructions are stored

in memory as patterns of switches turned on or oﬀ. When a machine language instruction

is loaded into the CPU, all that happens is that certain switches are turned on or oﬀ in the

pattern that encodes that particular instruction. The CPU is built to respond to this pattern

by executing the instruction it encodes; it does this simply because of the way all the other

switches in the CPU are wired together.

So, you should understand this much about how computers work: Main memory holds

machine language programs and d ata. These are encoded as binary numbers. The CPU fetches

machine language instructions from memory one after another and executes them. It does

this mechanically, without thin king about or understanding what it does—and therefore the

program it executes must be perfect, complete in all details, and unamb iguous because the CPU

can do nothing but execute it exactly as written. Here is a schematic view of this ﬁrst-stage

understanding of the computer:

CHAPTER 1. THE MENTAL LANDSCAPE 3

Data to memory

Data from memory

Address for

reading/writing

data

1011100001

Program

counter:

CPU

Memory

(Location 0)

(Location 1)

(Location 2)

(Location 3)

(Location 10)

00101110

11010011

01010011

00010000

10111111

10100110

11101001

00000111

10100110

00010001

00111110

1.2 Asynchronous Events: Polling Loops and Interrupts

The CPU spends almost all of its time fetching instructions from memory and executing

(online)

them. However, the CPU and main memory are only two out of many components in a real

computer system. A complete system contains other devices such as:

• A hard disk for storing programs and data ﬁles. (Note that main memory holds only a

comparatively small amount of information, and holds it only as long as the power is turned

on. A hard disk is necessary for permanent storage of larger amounts of information, but

programs have to be loaded from disk into main memory before they can actually be

executed.)

• A keyboa rd and mouse for user input.

• A monitor and printer which can be used to display the computer’s output.

• A modem that allows the computer to communicate with other compu ters over telephone

lines.

• A network interface that allows the computer to communicate with other computers

that are connected to it on a network.

• A scanner that converts images into coded binary numbers that can be stored and

manipulated on the computer.

The list of devices is entirely open ended, and computer systems are built so that they can

easily be expanded by adding new devices. Somehow the CPU has to communicate with and

control all these devices. The CPU can only do this by executing machine language instructions

(which is all it can do, period). The way this works is that for each device in a system, there

is a device driver, which consists of software that the CPU executes when it h as to deal

with the device. In s talling a n ew device on a sys tem generally has two steps: plugging the

device physically into the computer, and in s talling the device driver softwar e. Without the

device d river, the actual physical device would be useless, since the CPU would not be able to

communicate with it.

CHAPTER 1. THE MENTAL LANDSCAPE 4

∗ ∗ ∗

A computer system consisting of many devices is typically organized by connecting those

devices to one or more busses. A bus is a set of wires that carry various sorts of information

between the devices conn ected to those wires. The wires carry data, addresses, and control

signals. An address directs the data to a particular device and perhaps to a particular register

or location within that device. Control signals can be used, for example, by one device to alert

another that data is available for it on the data bus. A fairly simple computer system might

be organized like this:

Input/

Output

Controller

Data bus

Address bus

Control bus

CPU

Empty Slot

for future

Expansion

Keyboard

Network

Interface

......

Network Cable

Video

Controller

and

Monitor

Memory

Now, devices such as keyboard, mouse, and network interf ace can produce input that needs

to be processed by the CPU. How does the CPU know that the data is there? One simple idea,

which turns out to be not very satisfactory, is for the CPU to keep checking for incoming data

over and over. Whenever it ﬁnds data, it processes it. This method is called polling, since

the CPU polls the input devices continually to see whether they have any input data to report.

Unfortunately, although polling is very simple, it is also very ineﬃcient. The CPU can waste

an awful lot of time just waiting for input.

To avoid this ineﬃciency, interrupts are often used instead of polling. An interrupt is

a signal sent by another device to the CPU. T he CPU responds to an interrupt signal by

putting aside whatever it is doing in order to respond to the interrupt. Once it has handled

the interrupt, it returns to what it was doing before the interrupt occurred. For example, when

you press a key on your computer keyboard, a keyboard interrupt is sent to the CPU. The

CPU responds to this signal by interrupting what it is doing, reading the key that you pressed,

processing it, and then returning to the task it was performing before you pressed the key.

Again, you should understand that this is a purely mechanical process: A device signals an

interrupt simply by turning on a wire. The CPU is built so that when that wire is turned on,

the CPU saves enough information about what it is currently doing so that it can return to

the same state later . This information consists of the contents of important internal registers

such as th e program counter. Then th e CPU jumps to some predetermined memory location

and begins executing the instructions stored there. Those instructions make up an interrupt

handler that does the processing necessary to respond to the interrupt. (This interrupt handler

is part of the device driver software for the device that signalled the interrupt.) At the end of

CHAPTER 1. THE MENTAL LANDSCAPE 5

the interrupt handler is an instruction th at tells the CPU to jump back to what it was doing;

it does that by restoring its previously saved state.

Interrupts allow the CP U to deal with asynchronous events. In the regular fetch-and-

execute cycle, things happen in a predetermined order; everything that happens is “synchr o-

nized” with everything else. Interrupts make it possible for the CPU to deal eﬃciently with

events that happen “asynchronously,” that is, at u npredictable times.

As an other example of how interrupts are used, consider what happens when the CPU needs

to access data that is stored on the hard disk. Th e CPU can access data directly only if it is

in main memory. Data on the disk has to be copied into memory before it can be accessed.

Unfortunately, on the scale of speed at which the CPU operates, the disk drive is extremely

slow. When the CPU needs data from the disk, it sends a signal to the disk drive telling it

to locate the data and get it ready. (This signal is sent synchronously, under the control of a

regular program.) Then, instead of just waiting the long and u npredictalble amount of time

that the disk drive will take to do this, the CPU goes on with some other task. When the disk

drive has the data ready, it sends an interrupt signal to the CPU. The interrupt handler can

then read the requested data.

∗ ∗ ∗

Now, you might have noticed that all this on ly makes sense if the CPU actually has several

tasks to perform. If it h as nothing better to do, it might as well spend its time polling for input

or waiting for disk drive operations to complete. All modern computers use multitasking to

perform several tasks at once. Some computers can be us ed by several people at once. Since the

CPU is so fast, it can quickly switch its attention from one user to another, devoting a fraction

of a second to each user in turn. This application of multitasking is called timesharing. But a

modern personal computer with just a single user also uses multitasking. For example, the user

might be typing a paper while a clock is continuously displaying the time and a ﬁle is being

downloaded over the network.

Each of the individual tasks that the CPU is working on is called a thread. (Or a process;

there are technical diﬀerences between threads and processes, but th ey are not important here.)

At any given time, only one thread can actually be executed by a CPU. The CPU will continue

runnin g the same thread until one of several things happens:

• The thread might voluntarily yield control, to give other threads a chance to run.

• The thread might have to wait for some asynchronous event to occur. For example, the

thread might request some data from the disk drive, or it might wait for the user to press

a key. While it is waiting, the thread is said to be blocked , and other threads have a

chance to run. When the event occurs, an interrupt will “wake up” the thread so that it

can continue running.

• The thread might use up its allotted slice of time and be s uspended to allow other threads

to run. Not all computers can “forcibly” suspend a thread in this way; those that can

are said to use p reemptive multitasking. To do preemptive multitasking, a computer

needs a special timer device that generates an interrupt at regular intervals, such as 100

times per second. When a timer interrupt occurs, the CPU has a chance to switch from

one thread to another, whether the thread that is currently running likes it or not.

Ordinary users, and indeed ordinary programmers, have no need to deal with interrupts and

interrupt handlers. They can concentrate on the diﬀerent tasks or threads that they want the

computer to perf orm; the details of how the computer manages to get all those tasks done are

not important to them. In fact, most users, and many programmers, can ignore thr eads and

CHAPTER 1. THE MENTAL LANDSCAPE 6

multitasking altogether. However, threads have become increasingly important as computers

have become more powerful and as they have begun to make more use of multitasking. Indeed,

threads are built into the Java programming language as a fundamental programming concept.

Just as important in Java and in modern programming in general is the basic concept of

asynchronous events. While programmers don’t actually deal with interrupts directly, they

do often ﬁnd themselves writing event handlers, which, like interrupt handlers, are called

asynchronous ly when speciﬁed events occur. Such “event-driven programming” has a very

diﬀerent feel fr om the more traditional straight-through, synchron ous programming. We will

begin with the more traditional type of programming, which is still used for programming

individual tasks, but we will return to threads and events later in the text.

∗ ∗ ∗

By the way, the s oftware that does all the interru pt h andling and the communication with

the user and with hardwar e devices is called the operating system. The operating system is

the basic, essential software without which a computer would not be able to function. Other

programs, such as word processors and World Wide Web browsers, are dependent upon the

operating system. Common operating systems include Linux, DOS, Windows 2000, Windows

XP, and the Macintosh OS.

1.3 The Java Virtual Mach ine

Machine language consists of very simple instructions that can be executed directly by

(online)

the CPU of a computer. Almost all programs, thou gh, are written in high-level programming

languages such as Java, Pascal, or C++. A program written in a high-level language cannot

be run directly on any computer. First, it has to be translated into machine language. This

translation can be done by a program called a compiler. A compiler takes a high-level-language

program and trans lates it into an executable machine-language program. O nce the translation

is done, the machine-language program can be run any number of times, but of course it can only

be r un on one type of computer (since each type of computer h as its own individual machine

language). If the program is to run on another type of computer it has to be re-translated,

using a diﬀerent compiler, into the appropriate mach ine langu age.

There is an alternative to compiling a h igh-level language program. Instead of using a

compiler, which translates the program all at once, you can use an interpreter, wh ich translates

it instruction-by-instruction, as necessary. An interpreter is a program that acts much like a

CPU, with a kind of fetch-and-execute cycle. In order to execute a program, the interpreter

runs in a loop in which it repeatedly reads one instruction from the program, decides what is

necessary to carry out that instruction, and then performs the appropriate machine-language

commands to do so.

One use of interpreters is to execute high-level language programs. For example, the pro-

gramming language Lisp is u s ually executed by an interpreter rather than a compiler. However,

interpreters have another purpose: they can let you use a machine-language program meant for

one type of computer on a completely diﬀerent type of computer. For example, there is a pro-

gram called “Virtual PC” that runs on Macintosh computers. Virtual PC is an inter preter that

executes mach ine-language programs written for IBM-PC-clone compu ters. If you run Virtual

PC on your Macintosh, you can run any PC program, including programs written for Windows.

(Unfortunately, a PC program will run much more slowly than it would on an actual IBM clone.

The problem is that Virtual PC executes several Macintosh machine-language instructions for

剩余689页未读，继续阅读

killer63

粉丝: 0
资源: 1

University of Illinois Java编程教程

英文版JAVA学习教程

java教程英文

最好的java教程，英文版的。官方java tutorial

JAVA教程

java 3D 英文教程

java教程（英文版）

美国某大学Java教程(英文)

java程序设计教程 英文

Java3D英文版教程

JAVA面向对象教程 Beginning Java Objects 英文版

最新资源

java程序设计教程英文