Conditions of Use
The book covers all parts needed for a freshman course. It is can be used as one semester or one year book for Java programming. read more
The book covers all parts needed for a freshman course. It is can be used as one semester or one year book for Java programming.
The syntax explanations are precise. The Java examples are error free.
The book doesn't use the most recent version of Java Environment. However, I do not think that is a problem. Beginners do not need the up-to-date new syntax to do well in a problem solving course.
The book is very concise, and easy to follow.
The book is very well organized in style. Similar formats are used from the beginning to the end.
The book follows the standard modularity for a first programming course. It begins with an introduction to computation, then followed by Java basics. It is a great book for a fast paced course. However, for some schools with a slow paced programming course, covering more basic programming skills and more examples could improve the learning experience.
I feel the book should cover the basics in more details and more examples. The order of the some topics are not conventional. For example, "if" structure is covered after the looping structures; and programming environment is in the last section of Chapter 2, not in the first section.
The book is very easy to use. The website offers online, PDF, and other ways to navigate.
I do not see any grammatical errors.
The book doesn't not make use of a lot of examples relevant to races, ethnicity, or diversity. However, I did not see any culturally insensitive, or offensive content.
I'd recommend the book for any one looking for a first year programming course.
This book is quite comprehensive and it provides all foundational topics for beginners to learn the Java programming language. In addition, it offers a nice overview of Java programming environments and includes chapters on graphical user... read more
This book is quite comprehensive and it provides all foundational topics for beginners to learn the Java programming language. In addition, it offers a nice overview of Java programming environments and includes chapters on graphical user interfaces and programming with multi-threading. The book is suitable for a typical first programming course in Java and some of the book’s material can also be used for a subsequent programming course.
I did not find any technical errors or inaccuracies in the book.
The current 8th edition of the book is based on Java 8 and it uses JavaFX for GUI programming, so the book’s content is quite up-to-date. Of course, as more features are periodically added to the Java language, the book will need to be revised accordingly.
The book is extremely well-written and easy to follow. In fact, the author uses a conversational writing style and provides clear explanations of concepts and principles throughout the book. All of these make it a good text book for beginners.
The author uses consistent terminology internally. But the term “subroutine” introduced in the book would not be consistent with other Java sources including Oracle’s Java Documentation where the term “method” is used. This external term inconsistency may cause some confusions to readers.
The book is generally modular. One could cluster and rearrange some of its chapters or sections to fit an intro to Java class. However, the book’s modularity could be further enhanced by re-organizing its coverage of some topics. For instance, it would be good to separate the section on recursion from linked data structures and to consider expanding it to a chapter because the recursion concept and recursive algorithms are usually difficult to comprehend for many beginners.
The author does a good job presenting the material in a logical manner. The book starts basic language constructs and then covers methods, program design, classes, arrays and some more advanced topics. At the end of each chapter, it also includes programming exercises and quizzes. One suggestion I have for book’s organization is to delay the coverage of some class related topics including inheritance, polymorphism and interfaces to a later chapter. In addition, the coverage on data structures (stacks, queues and binary trees) may be expanded so the book could also be used in a second programming course in Java.
The book’s interface is good and it is quite easy to navigate all book components. However, I feel the interface could be improved by adding a glossary and also an index.
This is a very well-edited book.
All examples and exercises from the book are very good and they are not culturally insensitive.
Overall, this is a great book for introducing Java programming. It has a very decent coverage of all important foundational topics and provides clear explanations and nice examples and exercises. Plus, it is freely accessible.
I will definitely consider using the book in some of my future classes.
The book covers all important and necessary topics for beginners in 13 chapters. read more
The book covers all important and necessary topics for beginners in 13 chapters.
The content is very accurate but here's minor things:
1. On page 14, the word "but" was typed twice (...but but has recently been removed...)
2. In section 10.1.4, the abbreviation for Java Collection Framework should be JCF not JFC.
Content is very fresh with a full of good examples and exercises. The previous version describes Swing libraries for the graphical user interface but the current version describes the up-to-date JavaFX.
The text was written with very easy words and explains concepts clearly with appropriate examples and pictures.
The text has a very good flow with a consistent jargon and framework. For example, in section 3.8, the concept of Arrays is introduced and explained later in detail in chapter 7. Also, the GUI programming is introduced in section 3.9 as an appetizer and described fully in chapter 6 and 13 with consistency.
The text is consisted of 13 chapters and many sub sections to facilitate any instructor/user to reconstruct/reorganize the content without any difficulties.
The essential topics of Java programming are organized in a way for beginners to read and study easily.
Any interface issues are found. The PDF file that can be downloaded from the open book site provides bookmark links to specific topics of interest, and the table of contents are hyperlinked. Also, all of the name of example code listed in the text have a link to actual code.
No grammatical errors are found.
The text is full of good examples and exercises without having any bias culturally and ethnically.
The introduction to the Conway’s Game of Life and the Checkers in chapter 7, and the Towers of Hanoi and the Blob Counting in chapter 8 are very useful examples for students who are interested in game programming. Also, 3 network programming examples (a simple chat room, a networked Tic-tac-toe game, and a networked Poker game) in section 12.5 could attract a lot of student's attention.
In section 6.1.3, when a BorderPane is explained, it would be good to show a picture of a BorderPane of the 5 section as shown in section 6.5.2 or place a link to that section.
This textbook is comprehensive. It covers a significant amount of material in a well-thought out and logical manner. The text starts with basic programming concepts introducing variables, types and input and output. The author covers the basics... read more
This textbook is comprehensive. It covers a significant amount of material in a well-thought out and logical manner. The text starts with basic programming concepts introducing variables, types and input and output. The author covers the basics of a variety of programming environments including Eclipse, NetBeans, and the command line environment. The next section introduces control structures, exception handling, and introduces arrays and GUI programming. The early introduction of arrays and GUI program is a nice feature, allow students to add address slightly more complex problems. The book introduces objects and classes late, allowing introductory students to focus on syntax and basic problem solving before adding objects. I believe the text is well suited to a two-semester introductory sequence, or an upper level Software Design Course. The text includes quizzes at the end of each chapter, as well as programming exercises.
I did not see any technical errors or inaccuracies in the book.
The book uses the Swing library used to build GUI applications. Swing has been replaced with JavaFX. Swing is still widely used and okay for an introductory courses; the text should be updated to cover JavaFX.
The author uses an easy to read, conversational writing style and provides very thorough explanations. The flow is very logical, with sections building on the prior section.
The author uses consistent, and for the most part, modern terminology. The use of “subroutine” can be a confusing to students. The more correct term “methods” is also used and it’s not clear why “subroutines” is introduced. I appreciate the use of JavaDoc.
The text is as modular, and the order that the modules are introduced in is very logical. It is possible to re-order the modules to match your preferences for introducing specific topics.
I like the organization of the book for an introductory course, and for a course on software design. approach. Objects and classes are covered in chapter five, after the basic programming building blocks such as control structures and methods have been covered. This allows you to choose the depth that you cover topics, going slower in an introductory class, but faster in a course on Software design. I would recommend moving some sections around. I like to introduce arrays early, and I defer exceptions until a bit later.
I did not find any interface issues. The text includes PDF links in the table of contents, and also when the text makes a reference to another section. The author also includes links to the full code examples on the book's web site. Figures are easy to read and high resolution.
The text is well edited. I found a very small number of spelling or grammatical errors in the book. The book is “cleaner” that many professional edited textbooks.
I didn't notice any instances of the text being culturally insensitive. It is difficult to always find neutral examples or references. The sample problems are appropriate.
This is one of the best Java programming texts that I have reviewed. I am currently using a different text and plan to switch to this text next semester. It is very detailed. The author provides explanations of the core concepts and provides great examples. The modular approach allows it to be used in an introductory CS class, with Java as a first language; and in a software design class focusing on object-oriented design.
This textbook is remarkably comprehensive. It covers a tremendous amount of material, including nearly every facet of the Java programming language (such as anonymous inner classes, lambdas, variable arity methods etc.). It also includes a... read more
This textbook is remarkably comprehensive. It covers a tremendous amount of material, including nearly every facet of the Java programming language (such as anonymous inner classes, lambdas, variable arity methods etc.). It also includes a chapter covering basic data structures such as lists, stacks, queues and binary trees, as well as chapters on multi-threading and networking, in addition to its thorough and integrated coverage of graphical user interfaces. When using this text for a one semester CS 1 course, I use roughly half of the content. I would probably not use it for a non-major's CS 0 course, as it could be an overwhelming amount of material for students.
The book is excellent for self-study - many students love having all the extra material available even if we don't cover it in class.
One area where I would have like to have seen more content is in the books coverage of recursion. There is one section in chapter nine dealing with recursion which contains four examples. Recursion is also used for implementing lists and trees, but it would be nice to have a slightly longer treatment as it is a confusing topic for many beginning students.
The text does not include an index. The book itself also does not contain a glossary, but there is one on the companion web site. The text includes quizzes at the end of each chapter, as well as programming exercises.
I did not notice any technical errors or inaccuracies in the book.
The book mostly covers Java 7, with some treatment of Java 8 features, so as of now, the book is perfectly up to date. Future changes to Java likely won't necessitate major changes to the text, and the author has updated the text several times (currently on version 7).
The one area of slight concern is with the Swing library used to build GUI applications. Oracle has replaced Swing with JavaFX, which is the new preferred way of writing GUIs in Java. Still, Swing is widely used and a fine thing to use for introductory courses. Moreover, Swing will be a supported part of Java for a long time as it is still so widely used.
I think the clarity of writing is the best feature of this text. The author uses an easy to read, conversational writing style. The text is also very thorough in its explanations.
The author does a good job using consistent terminology. He explains new terms which are introduced and is very careful about phrasing in general. For instance when talking about objects he has this to say:
"It is certainly not at all true to say that the object is 'stored in the variable std.' The proper terminology is that 'the variable std refers to or points to the object".
Actually speaking about the terminology explicitly like this is really helpful.
The text does use the term "subroutine". While it is internally consistent about this, it is not really consistent with other sources which nearly always refer to them as "methods" in the context of Java. It is not a big point, but students may be confused because they are not called subroutines in other resources they may consult.
The text is as modular as any other introductory programming text book I have seen. It wouldn't be possible to make sense of the example programs in later chapters without a solid mastery of the material in earlier chapters, but that's expected with this type of text. That said, the book does a good job of being as modular as it can. For instance, several of the later sections in a chapter can be skipped over, and, as I describe below, I re-arrange the material slightly to fit my course.
One caveat to this is that many of the examples in later chapters make use of the GUI programming from chapter six. When considering this text, you should be aware that its use of graphics is pretty fundamental and not something you could easily skip over. I see this as a positive as it adds some interest to the example programs which are graphical.
I like the organization of the book quite a lot. It does not use the "objects first" approach. Objects and classes are covered in chapter five, after the basic programming building blocks such as control structures and methods. I did find that some of the later sections within a chapter were things I didn't want to introduce to students at that point. For instance I skip the section on exceptions at the end of chapter three, and the sections on interfaces and nested classes at the end of chapter five.
I do think that the putting off arrays until chapter seven is a mistake, mostly because it is just hard to give good assignments that don't use arrays. When teaching with this book, I cover chapter seven after chapter four.
Overall though, the book does a fine job of transitioning from one topic to the next as it covers not only the particulars of the Java programming language, but the art of programming itself.
I did not find any interface issues at all. The text includes helpful PDF links in the table of contents, and also when the text makes a reference to another section. When discussing the example programs, the author also includes links to the full code on the book's web site, which is helpful. Figures are easy to read and high resolution. One suggestion I would have to improve the interface would be to include syntax highlighting for code listings.
The text is remarkably well edited for its length. I only noticed a handful of spelling or grammatical errors in the book.
I didn't notice any instances of the text being culturally insensitive. The text did not refer to people very often at all. In the few times it mentions the user or programmer, the author uses male and female pronouns equally. For instance at one point the text will mention a guess the number program telling the user "he lost", and later on saying a blackjack program should quit when the user wants to or when "she runs out of money".
I think this book is superior to other introductory programming texts that I have used, even without considering the fact that it is open and free. It is very detailed and provides clear expositions and great examples on everything that can be included in an introductory course (and then some). The few criticisms I have for the book can be easily worked around.
Table of Contents
- Chapter 1: Overview: The Mental Landscape
- Chapter 2: Programming in the Small I: Names and Things
- Chapter 3: Programming in the Small II: Control
- Chapter 4: Programming in the Large I: Subroutines
- Chapter 5: Programming in the Large II: Objects and Classes
- Chapter 6: Introduction to GUI Programming
- Chapter 7: Arrays and ArrayLists
- Chapter 8: Correctness, Robustness, Efficiency
- Chapter 9: Linked Data Structures and Recursion
- Chapter 10: Generic Programming and Collection Classes
- Chapter 11: Input/Output Streams, Files, and Networking
- Chapter 12: Threads and Multiprocessing
- Chapter 13: GUI Programming Continued
About the Book
Welcome to the Eighth Edition of Introduction to Programming Using Java, a free, on-line textbook on introductory programming, which uses Java as the language of instruction. This book is directed mainly towards beginning programmers, although it might also be useful for experienced programmers who want to learn something about Java. It is not meant to provide complete coverage of the Java language.
The eighth edition requires Java 8 or later, and it uses JavaFX for GUI programming. Version 8.1 is a small update of Version 8.0. This version briefly covers some of the new features in Java 11 and makes it clearer how to use this book with Java 11 and later.
About the Contributors
David J. Eck Ph.D. is a Professor at Department of Mathematics and Computer Science at the Hobart and William Smith Colleges.