input.txt")); int cansPerPack = 6; int n = in.nextInt(); double x = in.nextDouble(); String word = in.next(); String line = in.nextLine(); final double CAN_VOLUME = 0.335; public void addItem(double price) itemCount++; totalPrice = totalPrice + price; . . . Method Method Declaration Modifiers Return type Parameter type and name public static double cubeVolume(double sideLength) double volume = sideLength * sideLength * sideLength; return volume; Exits method and Selected Operators and Their Precedence (See Appendix B for the complete list.) Array element access ++ -- ! * / % + < <= > >= == != Increment, decrement, Boolean not Multiplication, division, remainder Addition, subtraction Comparisons Equal, not equal Boolean and Boolean or Assignment Math.sqrt(x) Math.log10(x) Math.abs(x) Raising to a power x y Square root Decimal log log10(x) Absolute value |x| Math.sin(x) Sine, cosine, tangent of x (x in radians) Math.tan(x) Conditional Statement Condition if (floor >= 13) Executed when condition is true actualFloor = floor - 1; else if (floor >= 0) Second condition (optional) actualFloor = floor; else Executed when System.out.println("Floor negative"); all conditions are false (optional) String Operations String s = "Hello"; int n = s.length(); // 5 char ch = s.charAt(1); // 'e' String t = s.substring(1, 4); // "ell" String u = s.toUpperCase(); // "HELLO" if (u.equals("HELLO")) ... // Use equals, not == for (int i = 0; i < s.length(); i++) char ch = s.charAt(i); Process ch Loop Statements Condition Initialization Condition Update for (int i = 0; i < 10; i++) System.out.println(i); bj6_insidecovers_8x10.indd 1 Add elements to the end names.add(1, "Bob"); // [Ann, Bob, Cindy] names.remove(2); // [Ann, Bob] names.set(1, "Bill"); // [Ann, Bill] Does not advance to new line. Use + to concatenate values. Executed while condition is true Loop body executed at least once System.out.print("Enter a positive integer: "); input = in.nextInt(); while (input <= 0); Set to a new element in each iteration An array or collection for (double value : values) Executed for each element sum = sum + value; System.out.println("Volume: " + volume); Field width Precision System.out.printf("%-10s %10d %10.2f", name, qty, price); Left-justified string Integer Floating-point number try (PrintWriter out = new PrintWriter("output.txt")) Write to out Use the print/println/printf methods. The output is closed at the end of the try-with-resources statement. Arrays Element type Element type (optional) String name = names.get(0); // Gets "Ann" System.out.println(names); // Prints [Ann, Bill] Mathematical Operations Math.pow(x, y) Initially empty names.add("Ann"); names.add("Cindy"); // [Ann, Cindy], names.size() is now 2 System.out.print("Enter a value: "); Math.cos(x) while (balance < TARGET) year++; balance = balance * (1 + rate / 100); Output Use wrapper type, Integer, Double, etc., for primitive types. ArrayList names = new ArrayList(); while (in.hasNextDouble()) double x = in.nextDouble(); Process x returns result. Array Lists Input Element type Length Linked Lists, Sets, and Iterators LinkedList names = new LinkedList<>(); names.add("Bob"); // Adds at end ListIterator iter = names.listIterator(); iter.add("Ann"); // Adds before current position String name = iter.next(); // Returns "Ann" iter.remove(); // Removes "Ann" Set names = new HashSet<>(); names.add("Ann"); // Adds to set if not present names.remove("Bob"); // Removes if present Iterator iter = names.iterator(); while (iter.hasNext()) Process iter.next() Maps All elements are zero. int[] numbers = new int[5]; int[] squares = { 0, 1, 4, 9, 16 }; int[][] magicSquare = { 16, 3, 2, 13}, { 5, 10, 11, 8}, { 9, 6, 7, 12}, { 4, 15, 14, 1} Key type Value type Map scores = new HashMap<>(); Returns null if key not present scores.put("Bob", 10); Integer score = scores.get("Bob"); for (String key : scores.keySet()) Process key and scores.get(key) for (int i = 0; i < numbers.length; i++) numbers[i] = i * i; for (int element : numbers) Process element System.out.println(Arrays.toString(numbers)); // Prints [0, 1, 4, 9, 16] 4/30/15 3:48 PM Big Java 6/e Early Objects Cay Horstmann San Jose State University VICE PRESIDENT AND EXECUTIVE PUBLISHER DIRECTOR EXECUTIVE EDITOR EDITORIAL PROGRAM ASSISTANT MARKETING MANAGER SENIOR PRODUCT DESIGNER DESIGN DIRECTOR SENIOR DESIGNER SENIOR PHOTO EDITOR SENIOR CONTENT EDITOR SENIOR PRODUCTION EDITOR PRODUCTION MANAGEMENT SERVICES COVER DESIGN COVER PHOTOS Laurie Rosatone Don Fowley Bryan Gambrel Jessy Moor Dan Sayre Jennifer Welter Harry Nolan Madelyn Lesure Billy Ray Karoline Luciano Tim Lindner Cindy Johnson Madelyn Lesure (tiger) Aprison Photography/Getty Images, Inc.; (rhino) irawansubingarphotography/Getty Images, Inc.; (bird) Nengloveyou/Shutterstock; (monkey) © Ehlers/iStockphoto. This book was set in 10.5/12 Stempel Garamond LT Std by Publishing Services, and printed and bound by Quad Graphics/Versailles. The cover was printed by Quad Graphics/Versailles. This book is printed on acid-free paper. ∞ Founded in 1807, John Wiley & Sons, Inc. has been a valued source of knowledge and understanding for more than 200 years, helping people around the world meet their needs and fulfill their aspirations. Our company is built on a foundation of principles that include responsibility to the communities we serve and where we live and work. In 2008, we launched a Corporate Citizenship Initiative, a global effort to address the environmental, social, economic, and ethical challenges we face in our business. Among the issues we are addressing are carbon impact, paper specifications and procurement, ethical conduct within our business and among our vendors, and community and charitable support. For more information, please visit our website: the 1976 United States or authorization through payment of the appropriate per-copy fee to the Web at www. Department, John Wiley & Sons, Inc., 111 River Street, Hoboken, NJ 07030-5774, (201) 748-6011, fax (201) 748-6008, or online at: Evaluation copies are provided to qualified academics and professionals for review purposes only, for use in their courses during the next academic year. These copies are licensed and may not be sold or transferred to a third party. Upon completion of the review period, please return the evaluation copy to Wiley. Return instructions and a free of charge return shipping label are available at: Outside of the United States, please contact your local representative. BRV 9 -05644-7 10 9 8 7 6 5 4 3 2 1 P R E FA C E This book is an introduction to Java and computer programming that focuses on the essentials—and on effective learning. The book is designed to serve a wide range of student interests and abilities and is suitable for a first course in programming for computer scientists, engineers, and students in other disciplines. No prior programming experience is required, and only a modest amount of high school algebra is needed. Here are the key features of this book: Start objects early, teach object orientation gradually. In , students learn how to use objects and classes from the standard library. shows the mechanics of implementing classes from a given specification. Students then use simple objects as they master branches, loops, and arrays. Objectoriented design starts in . This gradual approach allows students to use objects throughout their study of the core algorithmic topics, without teaching bad habits that must be un-learned later. Guidance and worked examples help students succeed. Beginning programmers often ask “How do I start? Now what do I do?” Of course, an activity as complex as programming cannot be reduced to cookbook-style instructions. However, step-by-step guidance is immensely helpful for building confidence and providing an outline for the task at hand. “How To” guides help students with common programming tasks. Additional Worked Examples are available online. Problem solving strategies are made explicit. Practical, step-by-step illustrations of techniques help students devise and evaluate solutions to programming problems. Introduced where they are most relevant, these strategies address barriers to success for many students. Strategies included are: • Algorithm Design (with pseudocode) • Tracing Objects • First Do It By Hand (doing sample calculations by hand) • Flowcharts • Selecting Test Cases • Hand-Tracing • Storyboards • Solve a Simpler Problem First • Adapting Algorithms • Discovering Algorithms by Manipulating Physical Objects • Patterns for Object Data • Thinking Recursively • Estimating the Running Time of an Algorithm Practice makes perfect. Of course, programming students need to be able to implement nontrivial programs, but they first need to have the confidence that they can succeed. This book contains a substantial number of self-check questions at the end of each section. “Practice It” pointers suggest exercises to try after each section. And additional practice opportunities, including automatically-graded programming exercises and skill-oriented multiple-choice questions, are available online. iii Preface A visual approach motivates the reader and eases navigation. Focus on the essentials while being technically accurate. © Terraxplorer/iStockphoto. Photographs present visual analogies that explain the nature and behavior of computer concepts. Step-bystep figures illustrate complex program operations. Syntax boxes and example tables present a variety of typical and special cases in a compact format. It is easy to get the “lay of the land” by browsing the visuals, before focusing on the textual material. Visual features help the reader An encyclopedic coverage is not helpful for a begin- with navigation. ning programmer, but neither is the opposite— reducing the material to a list of simplistic bullet points. In this book, the essentials are presented in digestible chunks, with separate notes that go deeper into good practices or language features when the reader is ready for the additional information. You will © Terraxplorer/iStockphoto. not find artificial over-simplifications that give an illusion of knowledge. Reinforce sound engineering practices. A multitude of useful tips on software quality and common errors encourage the development of good programming habits. The optional testing track focuses on test-driven development, encouraging students to test their programs systematically. Provide an optional graphics track. Graphical shapes are splendid examples of objects. Many students enjoy writing programs that create drawings or use graphical user interfaces. If desired, these topics can be integrated into the course by using the materials at the end of Chapters 2, 3, and 10. Engage with optional science and business exercises. End-of-chapter exercises are enhanced with problems from scientific and business domains. Designed to engage students, the exercises illustrate the value of programming in applied fields. New to This Edition Updated for Java 8 Java 8 introduces many exciting features, and this edition has been updated to take advantage of them. Interfaces can now have default and static methods, and lambda expressions make it easy to provide instances of interfaces with a single method. The chapter on interfaces and the sections that cover sorting have been updated to make these innovations optionally available. A new chapter covers the Java 8 stream library and its applications for “big data” processing. In addition, Java 7 features such as the try-with-resources statement are now integrated into the text. covers the utilities provided by the Paths and Files classes. Interactive Learning Additional interactive content is available that integrates with this text and immerses students in activities designed to foster in-depth learning. Students don’t just watch Preface v animations and code traces, they work on generating them. The activities provide instant feedback to show students what they did right and where they need to study more. To find out more about how to make this content available in your course, visit “CodeCheck” is an innovative online service that students can use to work on programming problems. You can assign exercises that have already been prepared, and you can easily add your own. Visit to learn more and to try it out. A Tour of the Book The book can be naturally grouped into four parts, as illustrated by Figure 1 on page vi. The organization of chapters offers the same flexibility as the previous edition; dependencies among the chapters are also shown in the figure. Part A: Fundamentals (Chapters 1–7) contains a brief introduction to computer science and Java programming. shows how to manipulate objects of predefined classes. In , you will build your own simple classes from given specifications. Fundamental data types, branches, loops, and arrays are covered in Chapters 4–7. Preface Part B: Object-Oriented Design (Chapters 8–12) takes up the subject of class design in a systematic fashion, and it introduces a very simple subset of the UML notation. The discussion of polymorphism and inheritance is split into two chapters. covers inheritance and polymorphism, whereas covers interfaces. Exception handling and basic file input/ output are covered in . The exception hierarchy gives a useful example for 1. Introduction Fundamentals 2. Using Objects Object-Oriented Design Data Structures & Algorithms Applied Topics 3. Implementing Classes Online Chapters 4. Fundamental Data Types 5. Decisions 6. Loops Sections 11.1 and 11.2 (text file processing) can be covered with . 7. Arrays 6. Iteration and Array Lists 11. Input/Output and Exception Handling 21. Advanced Input/Output 23. Internet Networking 8. Designing Classes 24. Relational Databases 9. Inheritance 13. Recursion 15. The Java Collections Framework 26. Web Applications 20. Graphical User Interfaces Figure 1 Chapter Dependencies Multithreading 25. XML 14. Sorting and Searching 19. Stream Processing 10. Interfaces 12. ObjectOriented Design 16. Basic Data Structures 18. Generic Classes 17. Tree Structures Preface vii inheritance. contains an introduction to object-oriented design, including two significant case studies. Part C: Data Structures and Algorithms (Chapters 13–19) Chapters 13 through 19 contain an introduction to algorithms and data structures, covering recursion, sorting and searching, linked lists, binary trees, and hash tables. These topics may be outside the scope of a one-semester course, but can be covered as desired after (see Figure 1). Recursion, in , starts with simple examples and progresses to meaningful applications that would be difficult to implement iteratively. covers quadratic sorting algorithms as well as merge sort, with an informal introduction to big-Oh notation. Each data structure is presented in the context of the standard Java collections library. You will learn the essential abstractions of the standard library (such as iterators, sets, and maps) as well as the performance characteristics of the various collections. introduces Java generics. This chapter is suitable for advanced students who want to implement their own generic classes and methods. Finally, introduces the Java 8 streams library and shows how it can be used to analyze complex real-world data. Part D: Applied Topics (Chapters 20–26) Chapters 20 through 26 cover Java programming techniques that definitely go beyond a first course in Java (21–26 are on the book’s companion site). Although, as © Alex Slobodkin/iStockphoto. already mentioned, a comprehensive coverage of the Java library would span many volumes, many instructors prefer that a textbook should give students additional reference material valuable beyond their first course. Some institutions also teach a second-semester course that covers more practical programming aspects such as database and network programming, rather than the more traditional in-depth material on data structures and algorithms. This book can be used in a two-semester course to give students an introduction to programming fundamentals and broad coverage of applications. Alternatively, the material in the final chapters can be useful for student projects. The applied topics include graphical user-interface design, advanced file handling, multithreading, and those technologies that are of particular interest to server-side programming: networking, databases, XML, and web applications. The Internet has made it possible to deploy many useful applications on servers, often accessed by nothing more than a browser. This server-centric approach to application development was in part made possible by the Java language and libraries, and today, much of the industrial use of Java is in server-side programming. Appendices Many instructors find it highly beneficial to require a consistent style for all assignments. If the style guide in Appendix E conflicts with instructor sentiment or local customs, however, it is available in electronic form so that it can be modified. Appendices F–J are available on the Web. A. The Basic Latin and Latin-1 Subsets of Unicode B. Java Operator Summary C. Java Reserved Word Summary D. The Java Library E. Java Language Coding Guidelines F. Tool Summary G. Number Systems H. UML Summary I. Java Syntax Summary J. HTML Summary viii Preface Custom Book and eBook Options Big Java may be ordered in both custom print and eBook formats. You can order a custom print version that includes your choice of chapters—including those from other Horstmann titles. Visit customselect.wiley.com to create your custom order. Big Java is also available in an electronic eBook format with three key advantages: • The price is significantly lower than for the printed book. • The eBook contains all material in the printed book plus the web chapters and worked examples in one easy-to-browse format. • You can customize the eBook to include your choice of chapters. The interactive edition of Big Java adds even more value by integrating a wealth of interactive exercises into the eBook. See to find out more about this new format. Please contact your Wiley sales rep for more information about any of these options or check for available versions. Web Resources This book is complemented by a complete suite of online resources. Go to com/college/horstmann to visit the online companion sites, which include • Source code for all example programs in the book and its Worked Examples, plus additional example programs. • Worked Examples that apply the problem-solving steps in the book to other realistic examples. • Lecture presentation slides (for instructors only). • Solutions to all review and programming exercises (for instructors only). • A test bank that focuses on skills, not just terminology (for instructors only). This extensive set of multiple-choice questions can be used with a word processor or imported into a course management system. • “CodeCheck” assignments that allow students to work on programming problems presented in an innovative online service and receive immediate feedback. Instructors can assign exercises that have already been prepared, or easily add their own. WORKED EXAMPLE 6.3 Pointers in the book describe what students will find on the Web. A Sample Debugging Session Learn how to find bugs in an algorithm for counting the syllables of a word. Go to wiley.com/go/bjeo6examples and download Worked Example 6.3. FULL CODE EXAMPLE Go to wiley.com/go/ bjeo6code to download a program that demonstrates variables and assignments.