蓝桥版《ObjectsFirst with Java》：实践导向的OOP教程

需积分: 32 146 浏览量更新于2024-07-23 收藏 7.63MB PDF 举报

"《Objects First with Java™: A Practical Introduction Using BlueJ, Fifth Edition》是一本独特的Java基础教材，它在中国的传统教学方法之外提供了新颖的学习体验。该书特别强调面向对象（Object-oriented）编程思想，其核心特色在于配套的BlueJ编程环境。BlueJ是一种可视化的编程工具，旨在简化学习过程，让学生更好地理解关键编程概念和技术。 BlueJ环境中的VideoNotes是该教材的一大亮点。这是一种视频教学辅助工具，通过短小精悍的步骤指导，从设计到编码，逐步解决实际问题。学生可以根据自己的节奏进行自我学习，每个VideoNote都支持无缝导航，包括播放、倒退、快进和暂停等操作，使学习过程更加灵活和高效。购买新书后，赠送的六个月预付视频访问权限提供了全面的在线支持。初次使用VideoNotes，学生需要在互联网连接的计算机上注册，这个过程非常简单，只需几分钟完成一次。注册的网址是<http://www.pearsonhighered.com>，注册完成后，即可开始利用这些视频资源深入理解和掌握Java编程的基础知识。《Objects First with Java using BlueJ》不仅提供了一套完整的Java教程，而且通过创新的教学方式，帮助学生在实践中掌握面向对象编程的核心理念，对于想要系统学习Java的新手来说，这本书无疑是一个理想的起点。"

Preface

New to the fifth edition

This is the fifth edition of this book and we have taken the opportunity to incorporate

several significant changes from previous editions.

■

Java 7 features have been incorporated where appropriate

● The “diamond notation” (generic type inference) is covered when introducing generics.

● Coverage of appropriate new classes from the nio package for I/O.

● Strings are shown in switch statements.

● The new exception handling syntax is covered, including multi-catch and try-

with-resources.

■

New engaging projects using music files and social media have been added throughout

the book. Many other examples have been changed, updated and improved.

■

Unit testing is now based on JUnit 4.

■

BlueJ version is 3.0.5 is available on the accompanying DVD. This version includes

scope coloring, JUnit 4, and Java 7 support.

■

Includes VideoNotes—short video tutorials to reinforce key concepts throughout the book.

■

Expanded coverage of collections and iteration in Chapter 4 .

■

Access to the Blueroom, a BlueJ instructor community and forum designed for

resource sharing and collaboration with the authors and other instructors teaching

using BlueJ.

Some of these changes are the result of the introduction of language changes in Java 7.

We discuss diamond notation, use of strings in switch statements, changes to exception

handlers, and some of the nio classes, for instance. But the examples can still be used by

those who have not upgraded to Java 7, yet.

The majority of the changes in this edition, however, are the result of the nearly ten years

of experience we have now developed from using this material with our students, along

with feedback from our fellow instructors and readers. A particular example is the expan-

sion of the coverage of collections and iteration in Chapter 4 , but there are many other

smaller expansions where we have sought to clarify topics needing a little more explana-

tion. We have also changed the order of Chapters 6 and 7 to give a flow of topics that fits

more comfortably into a single semester for the first half of the book.

Preface

We have introduced several new projects to freshen up our coverage of existing topics.

These include a music-file organizer in Chapter 4 , an online shop in Chapter 7 , and a so-

cial network in Chapters 8 and 9 .

Nevertheless, the distinctive concept and style of this book, that have been there from the

beginning, remain unchanged because, overall, the book seems to be “working”.

Feedback we received from readers of prior editions was overwhelmingly positive, and

many people have helped in making this book better by sending in comments and sug-

gestions, finding errors and telling us about them, contributing material to the book’s web

site, contributing to the discussion forum, or translating the book into foreign languages.

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 engineering

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 use two tools throughout the book to enable the concepts introduced to be put into practice:

the Java programming language and the Java development environment BlueJ.

Java

Java was chosen because of a combination of two aspects: the language design and its popular-

ity. The Java programming language itself provides a very 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, com-

pilers, environments, and quizzes already exist, in many different kinds and styles. Many of

them are online and many are available free of charge. The large amount and good quality

of 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 think there is, and the second tool we use is one of the reasons…

BlueJ

The second tool, BlueJ, deserves more comment. This book is unique in its completely inte-

grated use of the BlueJ environment.

xvi

Preface

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, 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 environ-

ment 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 important 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, again 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 environment.

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

learners of software development. Some are aimed at helping with understanding fundamen-

tal 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 teaching.

It runs on top of Oracle’s Java Development Kit, and makes use of the standard compiler 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 environment

(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 a developer of the BlueJ system.

Real objects first

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 textbook

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 the first

Preface

xvii

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, textbooks typically either

■

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

around Chapter 4 ; 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, concepts such as

classes, objects, methods, and parameters can easily be discussed in a concrete 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 important

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 experience 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.

In this book we touch on all of the important topics several times, both within the same chapter

and across different chapters. Concepts are usually introduced at a level of detail necessary for

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.

xviii

Preface

understanding and applying the task at hand. They are revisited later in a different context, and

understanding deepens as the reader continues through the chapters. This approach also helps to

deal with the frequent occurrence of mutual dependencies between concepts.

Some teachers may not be familiar with an iterative approach. Looking at the first few chapters,

teachers used to a more sequential introduction will be surprised about the number of concepts

touched on this early. It may seem like a steep learning curve.

It is important to understand that this is not the end of the story. Students are not expected

to understand everything about these concepts immediately. Instead, these fundamental con-

cepts will be revisited again and again throughout the book, allowing students to get a deeper

and deeper understanding over time. Since their knowledge level changes as they work their

way forward, revisiting important topics later allows them to gain a deeper understanding

overall.

We have tried this approach with students many times. It seems that students have fewer prob-

lems dealing with it than some long-time teachers. And remember: a steep learning curve is not

a problem as long as you ensure that your students can climb it!

No complete language coverage

Related to our iterative approach is the decision not to try to provide complete coverage of the

Java language within the book.

The main focus of this book is to convey object-oriented programming principles in general,

not Java language details in particular. Students studying with this book may be working as

software professionals for the next 30 or 40 years of their life—it is a fairly safe bet that the

majority of their work will not be in Java. Every serious textbook must of course attempt to pre-

pare them for something more fundamental than the language flavor of the day.

On the other hand, many Java details are important for actually doing the practical work. In

this book we cover Java constructs in as much detail as is necessary to illustrate the concepts at

hand and implement the practical work. Some constructs specific to Java have been deliberately

left out of the discussion.

We are aware that some instructors will choose to cover some topics that we do not discuss

in detail. That is expected and necessary. However, instead of trying to cover every possible

topic ourselves (and thus blowing the size of this book out to 1500 pages), we deal with it

using hooks . Hooks are pointers, often in the form of questions that raise the topic and give

references to an appendix or outside material. These hooks ensure that a relevant topic is

brought up at an appropriate time, and leave it up to the reader or the teacher to decide to

what level of detail that topic should be covered. Thus, hooks serve as a reminder of the

existence of the topic, and as a placeholder indicating a point in the sequence where discus-

sion can be inserted.

Individual teachers can decide to use the book as it is, following our suggested sequence, or to

branch out into sidetracks suggested by the hooks in the text.

Chapters also often include several questions suggesting discussion material related to the

topic, but not discussed in this book. We fully expect teachers to discuss some of these ques-

tions in class, or students to research the answers as homework exercises.

剩余577页未读，继续阅读

issac5234

粉丝: 0
资源: 9

蓝桥版《ObjectsFirst with Java》：实践导向的OOP教程

java ide bluej

java课件（BlueJ教材）

BlueJ安装软件程序

BlueJ java编译器

BlueJ Java IDE:简单但功能强大的Java IDE。-开源

bluej（java开发工具）

BlueJ - Java Bluetooth Stack-开源

用BlueJ的Java排序，初学者适用

Java与BlueJ（Ron McFadyen）Java with BlueJ (Ron McFadyen)

用BlueJ助推Java程序设计教学改革.pdf

最新资源