《Objects First with Java》：蓝鸟引导的Java实用入门指南

需积分: 10 184 浏览量更新于2024-07-18 收藏 24.78MB PDF 举报

"《Objects First with Java: A Practical Introduction Using BlueJ》第六版是一本面向Java编程初学者和进阶者的权威指南。本书由David J. Barnes和Michael Kölling合著，两位作者来自英国肯特大学，以其深入浅出的方式，引导读者通过实践学习Java语言。此书特别强调了面向对象编程（Object-Oriented Programming, OOP）的概念，是那些希望通过BlueJ这款集成开发环境（Integrated Development Environment, IDE）来掌握Java基础与进阶技术的读者的理想选择。本书适合于没有编程背景但想踏入IT行业的学生，以及希望巩固现有Java知识的专业人士。它从Java语言的基础概念出发，逐步深入到类、对象、封装、继承、多态等核心特性，让读者在实践中理解和运用Java。通过实例项目，读者可以学会如何创建和管理简单的应用程序，理解面向对象设计的原则，以及如何利用Java进行软件开发。此外，书中还涵盖了Java语言的关键特性和框架，如异常处理、集合框架、文件I/O以及网络编程等内容。对于使用BlueJ这个交互式环境，书中提供了详尽的指导，帮助读者熟悉其界面操作和调试工具，提高编程效率。该书的出版得到了多个城市出版社的支持，包括美国波士顿、哥伦比亚等地，以及全球范围内的其他重要城市。编辑团队由Marcia Horton担任副总裁和编辑总监，Tracy Johnson任执行编辑，展示了出版社对高质量内容的重视。从市场管理到项目实施，每个环节都有专人负责，确保书籍内容的精准和专业性。《Objects First with Java》不仅是一本实用的学习资料，也是一份全面的参考书，为Java开发者提供了一个从入门到精通的坚实基石。无论是初次接触编程的新手，还是寻求进一步提升的Java程序员，这本书都能成为他们探索Java世界的重要伙伴。"

Preface

New to the sixth edition

This is the sixth edition of this book, and—as always with a new edition—the content has

been adapted to the latest developments in object-oriented programs.

Many of the changes this time can, on the surface, be attributed to a new version of Java:

Java 8. This version was released in 2014 and is now very widely used in practice. In fact, it

is the fastest adoption of any new Java version ever released; so it is time also to change the

way we teach novice students.

The changes are, however, more than merely the addition of a few new language constructs.

The most significant new aspects in Java 8 center around new constructs to support a

(partial) functional programming style. And it is the growing popularity of functional

programming that is driving this change. The difference is much deeper, and much more

fundamental, than just adding new syntax. And it is the renaissance of the functional

ideas in modern programming generally—not only the existence of Java 8—that makes it

timely to cover these aspects in a modern edition of a programming textbook.

The ideas and techniques of functional programming, while fairly old and well known

in principle, have seen a marked boost of popularity in recent years, with new languages

being developed and selected functional techniques being incorporated into existing,

traditionally imperative languages. One of the primary reasons for this is the change

in computing hardware available, and also the changing nature of problems we wish to

tackle.

Almost all programming platforms now are concurrent. Even mid-range laptops and mobile

phones now have processors with multiple cores, making parallel processing a real possibil-

ity on everyday devices. But, in practice this is not happening on a large scale.

Writing applications that make optimal use of concurrent processing and multiple proces-

sors is very, very difficult. Most applications available today do not exploit current hard-

ware to a degree approaching anything that is theoretically possible.

This is not going to change much: the opportunity (and challenge) of parallel hardware will

remain, and programming these devices with traditional imperative languages will not get

any easier.

This is where functional programming enters the picture.

A01_BARN7367_06_SE_FM.indd 15 4/15/16 6:10 PM

Preface

With functional language constructs, it is possible to automate some concurrency very

efficiently. Programs can potentially make use of multiple cores without much effort on

the side of the programmer. Functional constructs have other advantages—more elegant

expression for certain problems and often clearer readability—but it is the ability to deal

with parallelism that will ensure that functional aspects of programming are going to stay

with us for a long time to come.

Every teacher who wants to prepare their students for the future should give them some

understanding of functional aspects as well. Without it, one will no longer be able to become

a master programmer. A novice certainly does not have to master all of functional program-

ming, but a basic understanding of what it is—and what we can achieve with it—is rapidly

becoming essential.

Exactly when functional techniques should be introduced is an interesting question. We

do not believe that there is a single right answer for this; various sequences are possible.

Functional programming could be covered as an advanced topic at the end of the traditional

corpus of this book, or it could be addressed when we first encounter the topics where it

is applicable, as an alternative to the imperative techniques. It could even be covered first.

An additional question is how to treat the traditional style of programming in those areas

where functional constructs are now available: should they be replaced, or do both need to

be covered?

For this book, we recognize that different teachers will have different constraints and

preferences. Therefore, we have designed a structure that—we hope—allows different

approaches, depending on the preference of the learner or teacher.

■ We have not replaced the “old-style” techniques. We cover the new, functional approach

in addition to the existing material. Functional constructs in Java are most prominent

when working with collections of objects, and the mastering traditional approach—using

loops and explicit iteration—is still essential for any programmer. Not only are there

millions of lines of code out there that are written in this style—and will be continued

to be written in this style—but there are also specific cases where it is necessary to use

these techniques even if one generally favors the new functional constructs. Mastering

both is the goal.

■ We present the new functional-construct-oriented material in the book where we discuss

the problems that these constructs address. For example, we address functional collection

processing as soon as we encounter collections.

■ Chapters and sections covering this new material are, however, clearly marked as

“advanced,” and are structured in a manner that they can safely be skipped on first read-

ing (or left out altogether).

■ The previous two points enable different approaches to studying this book: if time per-

mits, it can be read in the sequence it is presented, covering the full scope of material—

including functional approaches as alternatives to imperative ones—as the problems are

encountered which they address. If time is short, these advanced sections can be skipped,

and emphasis can be placed on a thorough grounding in imperative, object-oriented

programming. (We should emphasize that functional is not a contradiction to object-

oriented: whether the functional material is included in the study, or the course emphasis

A01_BARN7367_06_SE_FM.indd 16 4/15/16 6:10 PM

Preface

is largely on imperative techniques, every reader of this book will emerge with a good

understanding of object orientation!) Yet another way to approach the material is to skip

the advanced sections initially, and cover them as a separate unit at a later time. They

present alternative approaches to other constructs and can be covered independently.

We hope this makes clear that this book provides flexibility where readers want it, but also

guidance where a reader has no clear preference: just read it in the sequence it is written.

Apart from the major changes described so far, this edition also presents numerous minor

improvements. The overall structure, tone, and approach of the book is unchanged; ithas

worked very well in the past, and there is no reason to deviate from it. However, we

continuously re-evaluate and seek to improve where we see opportunities. We now have

almost 15 years of continuous experience teaching with this book, and this is reflected in the

many minor improvements throughout.

This book is an introduction to object-oriented programming for beginners. The main focus

of the book is general object-oriented and programming concepts from a software engineer-

ing perspective.

While the first chapters are written for students with no programming experience, later

chapters are suitable for more advanced or professional programmers as well. In particular,

programmers with experience in a non-object-oriented language who wish to migrate their

skills into object orientation should also be able to benefit from the book.

We us e two to ols throu ghout the book t o enable the concept s introdu ce d to b e put i nt o prac-

tice: the Java programming language and the Java development environment BlueJ.

Java

Java was chosen because of both its language design and its popularity. The Java programming

language itself provides a clean implementation of most of the important object-oriented

concepts, and serves well as an introductory teaching language. Its popularity ensures an

immense pool of support resources.

In any subject area, having a variety of sources of information available is very helpful,

for teachers and students alike. For Java in particular, countless books, tutorials, exercises,

compilers, environments, and quizzes already exist, in many different kinds and styles.

Many of them are online and many are available free of charge. The huge amount of high

quality support material makes Java an excellent choice as an introduction to object-oriented

programming.

With so much Java material already available, is there still room for more to be said about it?

We thin k there is, a nd the seco nd tool we use is o ne of the r easons...

BlueJ

BlueJ deserves much comment. This book is unique in its completely integrated use of the

BlueJ environment.

BlueJ is a Java development environment that is being developed and maintained by the

Computing Education Research Group at the University of Kent in Canterbury, UK,

A01_BARN7367_06_SE_FM.indd 17 4/15/16 6:10 PM

Preface

explicitly as an environment for teaching introductory object-oriented programming. It is

better suited to introductory teaching than other environments for a variety of reasons:

■ The user interface is much simpler. Beginning students can typically use the BlueJ

environment in a competent manner after 20 minutes of introduction. From then on,

instruction can concentrate on the important concepts at hand—object orientation and

Java—and no time needs to be wasted talking about environments, file systems, class

paths, or DLL conflicts.

■ The environment supports important teaching tools not available in other environments.

One of them is visualization of class structure. BlueJ automatically displays a UML-like

diagram representing the classes and relationships in a project. Visualizing these impor-

tant concepts is a great help to both teachers and students. It is hard to grasp the concept

of an object when all you ever see on the screen is lines of code! The diagram notation is

a simple subset of UML, tailored to the needs of beginning students. This makes it easy

to understand, but also allows migration to full UML in later courses.

■ One of the most important strengths of the BlueJ environment is the user’s ability to

directly create objects of any class, and then to interact with their methods. This creates

the opportunity for direct experimentation with objects, with little overhead in the envi-

ronment. Students can almost “feel” what it means to create an object, call a method,

pass a parameter, or receive a return value. They can try out a method immediately after

it has been written, without the need to write test drivers. This facility is an invaluable

aid in understanding the underlying concepts and language details.

■ BlueJ includes numerous other tools and characteristics that are specifically designed

for students of software development. Some are aimed at helping with understanding

fundamental concepts (such as the scope highlighting in the editor), some are designed

to introduce additional tools and techniques, such as integrated testing using JUnit, or

teamwork using a version control system, such as Subversion, once the students are

ready. Several of these features are unique to the BlueJ environment.

BlueJ is a full Java environment. It is not a cut-down, simplified version of Java for teach-

ing. It runs on top of Oracle’s Java Development Kit, and makes use of the standard com-

piler and virtual machine. This ensures that it always conforms to the official and most

up-to-date Java specification.

The authors of this book have many years of teaching experience with the BlueJ environ-

ment (and many more years without it before that). We both have experienced how the

use of BlueJ has increased the involvement, understanding, and activity of students in our

courses. One of the authors is also the development lead of the BlueJ system.

Real objects rst

One of the reasons for choosing BlueJ was that it allows an approach where teachers truly

deal with the important concepts first. “Objects first” has been a battle cry for many text-

book authors and teachers for some time. Unfortunately, the Java language does not make

this noble goal very easy. Numerous hurdles of syntax and detail have to be overcome before

A01_BARN7367_06_SE_FM.indd 18 4/15/16 6:10 PM

Preface

the first experience with a living object arises. The minimal Java program to create and call

an object typically includes

■ writing a class;

■ writing a main method, including concepts such as static methods, parameters, and arrays

in the signature;

■ a statement to create the object (“new”);

■ an assignment to a variable;

■ the variable declaration, including variable type;

■ a method call, using dot notation;

■ possibly a parameter list.

As a result, most textbooks typically either

■ have to work their way through this forbidding list, and only reach objects somewhere

around the fourth chapter; or

■ use a “Hello, world”-style program with a single static main method as the first example,

thus not creating any objects at all.

With BlueJ, this is not a problem. A student can create an object and call its methods as

the very first activity! Because users can create and interact with objects directly, con-

cepts such as classes, objects, methods, and parameters can easily be discussed in a con-

crete manner before looking at the first line of Java syntax. Instead of explaining more

about this here, we suggest that the curious reader dip into Chapter 1—things will quickly

become clear then.

An iterative approach

Another important aspect of this book is that it follows an iterative style. In the computing

education community, a well-known educational design pattern exists that states that impor-

tant concepts should be taught early and often.

It is very tempting for textbook authors to

try and say everything about a topic at the point where it is introduced. For example, it is

common, when introducing types, to give a full list of built-in data types, or to discuss all

available kinds of loop when introducing the concept of a loop.

These two approaches conflict: we cannot concentrate on discussing important concepts

first, and at the same time provide complete coverage of all topics encountered. Our experi-

ence with textbooks is that much of the detail is initially distracting, and has the effect of

drowning the important points, thus making them harder to grasp.

The “Early Bird” pattern, in J. Bergin: “Fourteen Pedagogical Patterns for Teaching Computer

Science,” Proceedings of the Fifth European Conference on Pattern Languages of Programs

(EuroPLop 2000), Irsee, Germany, July 2000.

A01_BARN7367_06_SE_FM.indd 19 4/15/16 6:10 PM

剩余666页未读，继续阅读

qq_42257085

粉丝: 0
资源: 1

《Objects First with Java》：蓝鸟引导的Java实用入门指南

Objects First with Java- A Practical Introduction Using BlueJ

Objects First with Java A Practical Introduct（实用JAVA教程）

实用java教程的答案

qml_pract

mongodb_pract

Pract_Project

SoftServe-pract

pract:你好你好

pract-repos-back

react_pract_counter

最新资源