Ebook Objects First With Java: A Practical Introduction Using BlueJ (2nd Edition), by David Barnes, Michael Kolling
Why must pick the hassle one if there is easy? Obtain the profit by buying guide Objects First With Java: A Practical Introduction Using BlueJ (2nd Edition), By David Barnes, Michael Kolling right here. You will obtain various means making an offer and also get the book Objects First With Java: A Practical Introduction Using BlueJ (2nd Edition), By David Barnes, Michael Kolling As understood, nowadays. Soft data of the books Objects First With Java: A Practical Introduction Using BlueJ (2nd Edition), By David Barnes, Michael Kolling come to be preferred with the visitors. Are you one of them? And right here, we are offering you the extra collection of ours, the Objects First With Java: A Practical Introduction Using BlueJ (2nd Edition), By David Barnes, Michael Kolling.
Objects First With Java: A Practical Introduction Using BlueJ (2nd Edition), by David Barnes, Michael Kolling
Ebook Objects First With Java: A Practical Introduction Using BlueJ (2nd Edition), by David Barnes, Michael Kolling
When you are hurried of task deadline and have no concept to obtain motivation, Objects First With Java: A Practical Introduction Using BlueJ (2nd Edition), By David Barnes, Michael Kolling book is among your options to take. Reserve Objects First With Java: A Practical Introduction Using BlueJ (2nd Edition), By David Barnes, Michael Kolling will give you the best source as well as point to get motivations. It is not just concerning the works for politic business, management, economics, and other. Some bought tasks making some fiction works additionally need inspirations to conquer the work. As what you need, this Objects First With Java: A Practical Introduction Using BlueJ (2nd Edition), By David Barnes, Michael Kolling will most likely be your choice.
Yet right here, we will show you astonishing point to be able constantly check out guide Objects First With Java: A Practical Introduction Using BlueJ (2nd Edition), By David Barnes, Michael Kolling anywhere as well as whenever you occur and time. Guide Objects First With Java: A Practical Introduction Using BlueJ (2nd Edition), By David Barnes, Michael Kolling by only can aid you to realize having guide to review each time. It will not obligate you to always bring the thick book anywhere you go. You could merely maintain them on the gizmo or on soft documents in your computer to consistently read the enclosure at that time.
Yeah, hanging out to review the publication Objects First With Java: A Practical Introduction Using BlueJ (2nd Edition), By David Barnes, Michael Kolling by on-line could likewise offer you positive session. It will alleviate to communicate in whatever problem. By doing this can be a lot more intriguing to do as well as easier to review. Now, to get this Objects First With Java: A Practical Introduction Using BlueJ (2nd Edition), By David Barnes, Michael Kolling, you can download in the link that we provide. It will certainly help you to obtain very easy means to download the publication Objects First With Java: A Practical Introduction Using BlueJ (2nd Edition), By David Barnes, Michael Kolling.
Guides Objects First With Java: A Practical Introduction Using BlueJ (2nd Edition), By David Barnes, Michael Kolling, from easy to challenging one will certainly be a very helpful jobs that you could take to alter your life. It will certainly not offer you negative statement unless you do not obtain the meaning. This is definitely to do in reading an e-book to conquer the significance. Typically, this e-book entitled Objects First With Java: A Practical Introduction Using BlueJ (2nd Edition), By David Barnes, Michael Kolling is checked out due to the fact that you actually similar to this type of book. So, you can get much easier to comprehend the perception as well as significance. Again to consistently remember is by reading this publication Objects First With Java: A Practical Introduction Using BlueJ (2nd Edition), By David Barnes, Michael Kolling, you could fulfil hat your interest begin by completing this reading publication.
The object-oriented paradigm continues to dominate the teaching of introductory computer programming. Objects First With Java is the first textbook to completely integrate the BlueJ Java development environment with the teaching of object-oriented principles. By using BlueJ, the authors are able to take a truly objects first approach, introducing the student to objects and classes from the outset, and enabling him/her to create an object and call its methods as the very first activity.
The authors move forward from traditional approaches on how best to tackle the complex concepts of object orientation, and deliver an outstanding text that is radically changing the way introductory programming is taught. Welcome to the BlueJ revolution!
- Sales Rank: #3301866 in Books
- Published on: 2004-07-22
- Original language: English
- Number of items: 1
- Dimensions: 9.75" h x 1.00" w x 7.50" l, .0 pounds
- Binding: Paperback
- 496 pages
From the Back Cover
The new edition of this best-seller brings it up to date with the latest developments in the field, and builds on the clear, accessible approach that has contributed to its success.
Objects First with Java
is an outstanding text that is radically changing the way introductory programming is taught. Welcome to the BlueJ revolution!
Key features
- Truly objects-first approach
- Project-driven approach to problem solving
- Thorough treatment of object-oriented principles
- CD-ROM containing the JDK and BlueJ for various operating systems
- A website at www.booksites.net/barnes containing the style guide for all examples used in the book, PowerPoint slides for instructors and other support material.
New to this edition
- New chapter on GUI programming and Swing
- Incorporates coverage of JUnit-style testing and assertions
- One hundred new exercises, many independent of the projects
- Four-colour new text design to improve pedagogy and aid student learning
From reviews of the first edition
"The book represents a valuable, new approach to introductory programming; it is still my best choice as textbook for the introductory programming course."
- Michael Caspersen, University of Aarhus, Denmark
"This is the most innovative approach to teaching an Introduction to Programming course I have seen so far."
- Clemens Martin, University of Ontario
"I would like to thank the authors for their good job on this book, and the wonderful BlueJ, the best programming environment for students learning Java."
- Ying Zhou, Rhode Island College
"The first true ¿objects first¿ introductory text; the best introduction to objects and OO programming concepts I have ever seen."
- Michael Goldweber, Xavier University
"The more I read Barnes and Kölling¿s book, the more impressed I am with it. It is a pedagogical masterpiece."
- Ian Bridgewood, Copenhagen University College of Engineering
About the Author
David Barnes is a Lecturer in Computer Science at the University of Kent, in Canterbury, England. He has been teaching introductory programming for over 25 years, and has practical experience of a wide range of programming languages. He has been teaching object-oriented programming in Java for over 10 years. David is passionate about the excitement that is inherent in computer science and is actively involved in promoting it as a subject area to high-school children. In addition to computing education, his main research is in the area of software engineering.
Michael Kölling is a Senior Lecturer at the Computing Laboratory, University of Kent, in Canterbury, England. He holds a PhD in computer science from Sydney University, and has worked in Australia, Denmark and the UK. Michael’s research interests are in the areas of object-oriented systems, programming languages, software tools, computing education. He has published numerous papers on object-orientation and computing education topics. Michael is one of the developers of BlueJ and, more recently, the Greenfoot platform.
Excerpt. © Reprinted by permission. All rights reserved.
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 B1ueJ.
Java
Java was chosen because of a combination of two aspects: the language design and its popularity. 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, 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 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 ...
BIueJ
The second tool, B1ueJ, deserves more comment. This book is unique in its completely integrated use of the B1ueJ environment.
BlueJ is a Java development environment that was designed at Monash University, Australia, 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 Blue) 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, DOS commands 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, for 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 is a full Java environment. It is not a cut-down, simplified version of Java for teaching. It runs on top of Sun Microsystems' 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 several 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 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 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 dependences 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 concepts 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 problems 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 prepare 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 a placeholder indicating a point in the sequence where discussion 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 questions in class, or students to research the answers as homework exercises.
Project-driven approach
The introduction of material in the book is project driven. The book discusses numerous programming projects and provides many exercises. Instead of introducing a new construct and then providing an exercise to apply this construct to solve a task, we first provide a goal and a problem. Analyzing the problem at hand determines what kinds of solutions we need. As a consequence, language constructs are introduced as they are needed to solve the problems before us.
Early chapters provide at least two discussion examples. These are projects that are discussed in detail to illustrate the important concepts of each chapter. Using two very different examples supports the iterative approach: each concept is revisited in a different context after it is introduced.
In designing this book we have tried to use a large number and wide variety of different example projects. This will hopefully serve to capture the reader's interest, but it also helps to illustrate the variety of different contexts in which the concepts can be applied. Finding good example projects is hard. We hope that our projects serve to give teachers good starting points and many ideas for a wide variety of interesting assignments.
The implementation for all our projects is written very carefully, so that many peripheral issues may be studied by reading the projects' source code. We are strong believers in the benefit of learning by reading and imitating good examples. For this to work, however, one must make sure that the examples students read are well written and worth imitating. We have tried to do this.
All projects are designed as open-ended problems. While one or more versions of each problem are discussed in detail in the book, the projects are designed so that further extensions and improvements can be done as student projects. Complete source code for all projects is included. A list of projects discussed in this book is provided on page xxv.
Concept sequence rather than language constructs
One other aspect that distinguishes this book from many others is that it is structured along fundamental software development tasks and not necessarily according to the particular Java language constructs. One indicator of this is the chapter headings. In this book you will not find many of the traditional chapter titles, such as `Primitive data types' or `Control structures'. Structuring by fundamental development tasks allows us to give a much more general introduction that is not driven by intricacies of the particular programming language utilized. We also believe that it is easier for students to follow the motivation of the introduction, and that it makes it much more interesting.
As a result of this approach, it is less straightforward to use the book as a reference book. Introductory textbooks and reference books have different, partly competing, goals. To a certain extent a book can try to be both, but compromises have to be made at certain points. Our book is clearly designed as a textbook, and wherever a conflict occurred, the textbook style took precedence over its use as a reference book.
We have, however, provided support for use as a reference book by listing the Java constructs introduced in each chapter in the chapter introduction.
Chapter sequence
Chapter 1 deals with the most fundamental concepts of object orientation: objects, classes and methods. It gives a solid, hands-on introduction to these concepts without going into the details of Java syntax. It also gives a first look at some source code. We do this by using an example of graphical shapes that can be interactively drawn, and a second example of a simple laboratory class enrollment system.
Chapter 2 opens up class definitions and investigates how Java source code is written to create behavior of objects. We discuss how to define fields and implement methods. Here, we also introduce the first types of statement. The main example is an implementation of a ticket machine. We also look back to the laboratory class example from Chapter 1 to investigate that a bit further.
Chapter 3 then enlarges the picture to discuss interaction of multiple objects. We see how objects can collaborate by invoking each other's methods to perform a common task. We also discuss how one object can create other objects. A digital alarm clock display is discussed that uses two number display objects to show hours and minutes. As a second major example, we examine a simulation of an email system in which messages can be sent between mail clients.
In Chapter 4 we continue by building more extensive structures of objects. Most importantly, we start using collections of objects. We implement an electronic notebook and an auction system to introduce collections. At the same time, we discuss iteration over collections and have a first look at loops. The first collection being used is an ArrayList. In the second half of the chapter we introduce arrays as a special form of a collection, and the for loop as another form of a loop. We discuss an implementation of a web-log analyzer as an example for array use.
Chapter 5 deals with libraries and interfaces. We introduce the Java standard library and discuss some important library classes. More importantly, we explain how to read and understand the library documentation. The importance of writing documentation in software development projects is discussed, and we end by practicing how to write suitable documentation for our own classes. Random, Set and Map are examples of classes that we encounter in this chapter. We implement an Eliza-like dialog system and a graphical simulation of a bouncing ball to apply these classes.
Chapter 6, titled Well-behaved objects, deals with a whole group of issues connected to producing correct, understandable and maintainable classes. It covers issues ranging from writing clear, understandable code—including style and commenting—to testing and debugging. Test strategies are introduced, and a number of debugging methods are discussed in detail. We use an example of a diary for appointment scheduling and an implementation of an electronic calculator to discuss these topics.
In Chapter 7 we discuss more formally the issues of dividing a problem domain into classes for implementation. We introduce issues of designing classes well, including concepts such as responsibility-driven design, coupling, cohesion and refactoring. An interactive, text-based adventure game (World of Zuul) is used for this discussion. We go through several iterations of improving the internal class structure of the game and extending its functionality, and end with a long list of proposals for extensions that may be done as student projects.
Chapters 8 and 9 introduce inheritance and polymorphism with many of the related detailed issues. We discuss a simple database of CDs and videos to illustrate the concepts. Issues of code inheritance, subtyping, polymorphic method calls and overriding are discussed in detail.
In Chapter 10 we implement a predator/prey simulation. This serves to discuss additional abstraction mechanisms based on inheritance, namely interfaces and abstract classes.
Chapter 11 then picks up the difficult issue of how to deal with errors. Several possible problems and solutions are discussed, and Java's exception-handling-mechanism is discussed in detail. We extend and improve an address book application to illustrate the concepts.
Chapter 12 steps back to discuss in more detail the next level of abstraction: how to structure a vaguely described problem into classes and methods. In previous chapters we have assumed that large parts of the application structure already exist, and we have made improvements. Now it is time to discuss how we can get started from a clean slate. This involves detailed discussion of what the classes should be that implement our application, how they interact, and how responsibilities should be distributed. We use class-responsibilities-collaborators (CRC) cards to approach this problem, while designing a cinema booking system.
In Chapter 13 we try to bring everything together and integrate many topics from the previous chapters of the book. 1t is a complete case study, starting with the application design, through design of the class interfaces, down to discussing many important functional and non-functional characteristics and implementation details. Topics discussed in earlier chapters (such as reliability, data structures, class design, testing and extendibility) are applied again in a new context.
Most helpful customer reviews
0 of 0 people found the following review helpful.
Written For Middle-Schoolers, Easy For Adults
By CJ
The very first programming book I read when I started trying to learn for real. Love the IDE it works with (written for middle-schoolers), love the textbook (written by authors who decided middle-schoolers needed their own IDE). It, and the visual IDE it works with, did a great job helping me learn to think object-orientedly before I ever wrote a "Hello World." There's so much visual feedback that helps you see initialization & garbage collection, state scope, etc. And the book follows a great program!
We didn't follow it in my 1st class (it was a suggested extra), but I was so glad I got a few chapters in before we started on our more procedurally-oriented Java book. I was way ahead of my classmates when we started covering static vs. object code.
0 of 0 people found the following review helpful.
Hard to find a better tutorial text, with its own teaching tool
By Tom Maynard
A gradual introduction to programming in the "objects first" tradition. The BlueJ IDE is a remarkable piece of work in its own right, and this text makes full use of all its features. Even better, you can continue using BlueJ long after you've finished the book ... it's not just a throwaway piece of pedagogy, but a valuable TDD tool for life.
The authors cover a wide spectrum of programming approaches, always guiding the student gently toward the goal.
It moves a bit slowly for my taste, but students these days aren't comfortable with hard work so it's probably a better fit.
1 of 1 people found the following review helpful.
Learning Java
By Jamie
As a beginner in programming this book has proven to be helpful. Finding useful information online is often difficult and confusing until you have some basic understanding of the code, which this book provides. However, the book doesn't keep quite the same pace as my software design class. Nor does it contain all relevant material. Switch statements are notably lacking form the book while not from the lectures. The book does do what it promises; it's a good introduction to the language and helpful in learning design and jargon.
See all 46 customer reviews...
Objects First With Java: A Practical Introduction Using BlueJ (2nd Edition), by David Barnes, Michael Kolling PDF
Objects First With Java: A Practical Introduction Using BlueJ (2nd Edition), by David Barnes, Michael Kolling EPub
Objects First With Java: A Practical Introduction Using BlueJ (2nd Edition), by David Barnes, Michael Kolling Doc
Objects First With Java: A Practical Introduction Using BlueJ (2nd Edition), by David Barnes, Michael Kolling iBooks
Objects First With Java: A Practical Introduction Using BlueJ (2nd Edition), by David Barnes, Michael Kolling rtf
Objects First With Java: A Practical Introduction Using BlueJ (2nd Edition), by David Barnes, Michael Kolling Mobipocket
Objects First With Java: A Practical Introduction Using BlueJ (2nd Edition), by David Barnes, Michael Kolling Kindle
Objects First With Java: A Practical Introduction Using BlueJ (2nd Edition), by David Barnes, Michael Kolling PDF
Objects First With Java: A Practical Introduction Using BlueJ (2nd Edition), by David Barnes, Michael Kolling PDF
Objects First With Java: A Practical Introduction Using BlueJ (2nd Edition), by David Barnes, Michael Kolling PDF
Objects First With Java: A Practical Introduction Using BlueJ (2nd Edition), by David Barnes, Michael Kolling PDF
