Goals

	Introduce students to the Java programming language;
	Present and encourage the use of the object-oriented paradigm;
	Demonstrate effective problem-solving techniques;
	Engage the student with real-world examples;
	Teach students software-engineering design concepts;
	Introduce students to Java's core and graphical libraries;
	Give students practice organizing and writing code;
	Teach students the practical skill of modifying existing code;
	Offer instructive examples of good and bad programming;
	Provide effective coverage of testing and debugging.

Features

	Coverage: Provides in-depth coverage of all materials that an introductory course would need, introduces much of the remaining material generally covered in follow-on courses, and gives pointers to the rest.
	Flexibility: The breadth and the arrangement of chapters provides flexibility for the instructor in what and when topics are introduced. The chapter coverage and extensive appendices enable advanced learners to go further, and makes the book valuable as a reference source.
	Gentle introduction to objects: The book implements what we call the "objects right" approach. Teaching the object-oriented paradigm in introductory courses for the last ten-plus years has shown us that Java can be successfully introduced to beginning programmers. We know that delaying user-defined classes to the end of a course inhibits the ability of students to integrate the central pillar of the object-oriented programming paradigm and forces superficial coverage of other important object-oriented programming principles. Therefore, our presentation introduces objects early—or as we prefer, right. Students begin using objects from standard packages right from the beginning. They quickly develop meaningful programs for interesting problems. Using this solid introduction, we then present the basics of class and object-oriented design. After exploring control structures, we present a deeper look at methods, classes, and object-oriented design.
	Focus on problem solving: One of the biggest obstacles faced by many beginning students is not knowing basic problem-solving techniques. The text addresses this issue by introducing basic problem-solving skills in Chapter 1 and then applying the new concepts in each chapter to problems selected for their appeal to a variety of audiences. Students are first walked through examples that illustrate effective problem solving, and then they are given a chance to tackle similar problems on their own.
	Introduction to software-engineering design concepts: Software-engineering design concepts are introduced via problem studies and software projects. Besides numerous small examples, each chapter considers one or more problems in detail. As appropriate, there are object-oriented analysis and design, and algorithm development to realize the design.
	Coverage of testing and debugging: An important skill for programmers is how to test and debug the programs they design and implement. Chapter 13 introduces important software engineering concepts and practices with regard to testing and debugging. The chapter discusses testing techniques such as unit testing, integration testing, and code inspections. The sections on debugging focus on teaching students how to use the scientific method to find errors. The chapter also discusses common errors of beginning programmers and how to recognize them. After control structures have been introduced, this chapter material can be taught whenever an instructor deems it appropriate.
	Engaging and inclusive examples: Students learn from interesting situations they might encounter in real life. Diverse case studies and programming projects are drawn from topics as varied as physical fitness, spam, medical diagnosis, statistical analysis, psychological typing, data visualization, graphs, entertainment, and animation. By offering this variety of examples, the text demonstrates how programmers can participate and contribute to our daily lives.
	Exclusive use of standard Java classes: The text uses only standard Java classes in introducing Java programming concepts. In particular, there are no author-written classes for acquiring input. Instead standard classes and techniques are presented in a way that makes sense to beginning programmers.
	Lab manual: A printed lab manual accompanies the text for schools that use laboratories in their introductory courses. The lab material offers a hands-on experience that reinforces Java programming concepts and skills.
	Programming and style tips: Besides explaining Java and object-oriented programming, the text also provides advice on how to be a better and more knowledgeable programmer and designer. There are important tips on such topics as avoiding common programming errors, writing readable code, and following software engineering practices.
	Self-test, exercises, and software projects: Every chapter provides a self-test exercise section with answers to enable students to evaluate their skills on important concepts. The text also provide several hundred exercises with solutions are available to instructors through the publisher. Once the basics of Java are introduced in Chapter 2, that chapter and all successive chapters supply a programming project that exercises chapter concepts.
	Reference appendices: Appendices C, D, and E provide nearly two hundred pages of description of the standard Java APIs. The coverage makes the text a handy reference manual well after the course completes.
	Full-color design: An inviting, full-color design highlights related material, indicates section breaks, calls out special features, and makes key information easy to reference.
	Code formatting: Specially formatted code listings make sections of code easy to find and reference. Each complete listing is numbered according to its place in the chapter, separated from related material by coloring and line numbering. Partial sections of code are clearly set off from surrounding text and are generously annotated with easy-to-spot author comments.
	UML diagrams: The use of UML diagrams helps clarify relationships between classes while at the same time familiarizing students with this widely used system of notation.
	Case studies: Each chapter includes multiple case studies designed to teach effective problem-solving skills and to reinforce object-oriented programming and software engineering design concepts. The specific learning objective is highlighted at the beginning of each case study, and problem-solving steps are highlighted with special icons. The case studies are colored to distinguish them from other chapter material. Coverage of the case studies is optional; they apply chapter concepts rather than introducing new concepts.
	End-of-chapter reviews: Each chapter ends with a thorough, point-by-point summary of the chapter's major ideas. The end of chapter materials are color highlighted for easy access.
	Self-tests: Each chapter includes a self-test with answers supplied at the end of the chapter. These self-check sections are designed to help students evaluate whether they have mastered the chapter objectives and to reinforce the key ideas of the chapter.
	Programming case studies: Each programming chapter has at least one interesting programming case study presented in a manner that makes it suitable for use as a class assignment. Programming case studies include determining your exercise training zone; harvesting e-mail addresses; medical diagnosis; automobile loan calculator; and an aquarium simulation.
	Exercises: An exercise section at the end of each chapter offers a variety of problems requiring a range of efforts levels.

Chapter summaries

	Chapter 1: Background Computer organization; software; software engineering principles; object-oriented software development; problem solving.
	Chapter 2: Java basics Program organization; method main(); commenting and whitespace; classes, keywords, identifiers, and naming conventions; methods; program execution; SDK; constants; variables; operations; primitive types; operators; precedence; interactive programs; primitive variable assignment.
	Chapter 3: Using object String; reference variables; null; inserting, extracting, and concatenating strings; reference assignment; String methods.
	Chapter 4: Being classy Introduces user-defined classes; instance variables; constructors; instance methods; inspectors; mutators; facilitators; simple graphics.
	Chapter 5: Decisions Boolean algebra and truth tables; logical expressions; boolean type; Boolean equality and ordering operators; testing floating-point values for equality; operator precedence; short-circuit evaluation; if statement; if-else statement; string and character testing; sorting; switch statement.
	Chapter 6: Iteration While statement; simple string and character processing; for statement; index variable scope; do-while statement.
	Graphics Interlude I Graphical user interfaces; swing; awt; and event-based programming
	Chapter 7: Programming with methods and classes Parameter passing; invocation and flow of control; class variables; scope; local scope; name reuse; overloading; overriding; equals(); toString(); clone().
	Chapter 8: Arrays and collections One-dimensional arrays; definitions; element access and manipulation; explicit initialization; constant arrays; members; array processing; methods; program parameters; sorting; searching; multidimensional arrays; matrices; collections framework; ArrayList; collections algorithms.
	Chapter 9: Inheritance and polymorphism Object-oriented design; reuse; base class; derived class; single inheritance; super; is-a, has-a, and uses-a relationships; controlling inheritance; default, protected, and private members; polymorphism; abstract base class; interface hierarchies.
	Graphics Interlude II Case studies in the design and implementation of graphical user interfaces for personality typing and the smiley guessing game.
	Chapter 10: Exceptions Abnormal event; exceptions; throwing; trying; catching; exception handlers; finally; stream specialization.
	Chapter 11: Recursive problem solving Recursive functions, sorting, searching, visualization.
	Chapter 12: Threads Multiple independent flows of control; processes; threads; scheduling and repeating threads; Timer; TimerTask; Thread; Date; Calendar; JOptionPane; sleeping; animation; systems software.
	Chapter 13: Testing and debugging Software development; code reviews; black-box and white-box testing; inspections; test harness; statement coverage; unit, integration testing, and system testing; regression testing; boundary conditions; path coverage; debugging.
	Appendix A: Tables and operators Unicode character set; reserved words; operators and precedence.
	Appendix B: Number representation Binary numbers; decimal numbers; two’s compliment; conversions.
	Appendix C: Applets Applet programming.
	Appendix D: Standard Java packages java.io; java.lang; java.math; java.net; java. text; java.util.
	Appendix E: Standard Java graphical packages java.applet, java.awt, and javax.swing.