Learn the exciting language for the World Wide Web This book is written in the clear and concise style that has made Winston's C, C++, and Lisp books popular among programmers who want to add new languages to their repertoires. Using this book, you learn Java quickly and effectively, and you learn why Java is the language of choice for writing programs for the World Wide Web.The Knowledge You Need Each section adds new capabilities to a short, yet representative Java program. As you see the program evolve, you learn how to: * Define abstract classes and abstract methods * Design class hierarchies * Use compilation units and packages * Use interfaces to impose requirements * Use the model-view approach to interface design * Access applets from network viewers * Use threads to implement dynamic applets * Design applets using layout managers Winston's proven approach: * Based on extensive teaching experience * Features easily digested segments * Illustrates ideas via short, yet complete programs * Answers your natural questions in a natural order * Stresses principles of good programming practice * Recapitulates key points as if-then rules * Shows you how to write programs right away In producing On To Java, PostScript files were printed on film,which was used to produce the copper plates that are used in the printingpress.When the PostScript files were sent to the film producer, one of theirprograms failed to clear a character table. Consequently,certain charactersthat appear in programs were replaced by spaces.This problem seems limited primarily to pages in the ranges 64--77 and 163--171. 020149826XB04062001

Table of Contents:
1. How This Book Teaches You the Language. Why you Should Learn Java. Object-Oriented Programming Languages. Java's Network-Oriented Features. Programming Cliches. 2. How to Compile and Run a Simple Program. Compiling and Executing. The Display Statement and Strings. Case Sensitivity and Blank insensitivity. Operators and Operands. 3. How to Declare Variables. Data Types and Variable Declarations. Initialization and Assignment. Integral and Floating-Point Data Types. 4. How to Write Arithmetic Expressions. Arithmetic. Precedence and Association. Binary and Unary Operators. Type Casting. 5. How to Define Simple Methods. Defining Methods. Calling and Returning From Methods. Arguments, Parameters, and Values. Method Overloading in Multiple Classes. Method Overloading in One lass. 6. How to Understand Variable Scope and Extent. Parameters. Local Variables. Blocks. 7. How to Benefit From Procedure Abstraction. Making Programs Easier to Reuse, Read, and Debug. Making Programs Easier to Augment, Improve, and Adapt. 8. How to Declare Class Variables Class Variables. Final Variables. 9. How to Create Class Instances. Instance Creation. Instance Variables. 10. How to Define Instance Methods. Defining Instance Methods. The Special, Target Argument. 11. How to Define Constructor Instance Methods. Constructors and Initialization. The Default Constructor. Constructors With Parameters. 12. How to Define Getter and Setter Methods. Getter and Setter Instance Methods. Imaginary Member Variables. 13. How to Benefit From Data Abstraction. Access Methods and Data Abstraction. Making Programs Easier to Reuse. 14. How to Protect Instance Variables From Harmful Access. Private Instance Variables and Instance Methods. The Public Interface. 15. How to Define Classes That Inherit Instance Variables and Methods. Subclasses and Superclasses. Inheriting Instance Variables and Instance Methods. Shadowing, Also Known As Overriding. 16. How to Define Abstract Classes and Abstract Methods. Classes Without Instances. Classes Without Subclasses. Methods Without Bodies. 17. How to Write Constructors That Call Other Constructors. Using This. Using Super. 18. How to Write Methods That Call Other Methods. Passing Along a Target Argument. The This Parameter. 19. How to Design Classes and Class Hierarchies. Explicit Representation. Reusing Methods and Avoiding Duplication. The Modularity Principle. The No-Duplication Principle. The Look-It-Up Principle. The Need-to-Know Principle. The Is-A Versus Has-A Principle. 20. How to Perform Tests Using Predicates. Predicates. Equal, ==, and Not Equal, !=. Greater Than, , and Less Than, <. Not, !. Casting Before Testing. 21. How to Write One-Way and Two-Way Conditional Statements. Boolean Expressions. If and If Else. Empty Statements. The Conditional Operator, ?:. 22. How to Combine Boolean Expressions. And, &&, And Or, ||. Evaluation Order. 23. How to Write Iteration Statements. While and For Statements. Augmented Assignment Operators. Increment, ++, and Decrement, --, Operators. Side Effects and Evaluation Order. 24. How to Write Recursive Methods. Recursive Methods. The Base Part and The Recursion Part. Efficiency Considerations. 25. How to Write Multiway Conditional Statements. Case and Default. Fall Through. 26. How to Create File Streams for Input. Creating File Input Streams. Creating Tokenizers. Stepping, Testing, and Reading From Tokenizers. 27. How to Create and Access Arrays. Declaring and Initializing Arrays. Arrays of Numeric Elements. Arrays of Class-Instance Elements. Arrays of Mixed Instance Types. 28. How to Move Arrays Into and Out of Methods. Using Arrays As Arguments. Returning Arrays From Methods. 29. How to Store Data in Expandable Vectors. Vectors Versus Arrays. Storing Elements in Vectors. Retrieving Elements From Vectors. Obtaining The Size of A Vector. Queues and Push-Down Lists. Casting Vector Elements Prior to Use. 30. How to Work With Characters and Strings. Characters. Strings. Extracting Characters From Strings. Combining Strings. 31. How to Catch Exceptions. Exception Handling. The Try Statement. Catch and Finally Blocks. Exit Statements. 32. How to Create File Streams For Output. Creating File Output Streams. Creating Print Streams. Printing to Print Streams. 33. How to Modularize Programs Using Compilation Units and Packages. Modularization. Grouping Class Into Compilation Units and Packages. Package Names and Path Names. 34. How to Use Protected and Private Variables and Methods. Public Instance Variable and Methods. Private Instance Variable and Methods. Public Instance Variable and Methods. 35. How to Use Interfaces to Impose Requirements. Interfaces as an Alternative to Multiple Inheritance. Defining Interfaces. Tying Classes to Interfaces. Interface Parameters and Variables. 36. How to Draw Lines in Windows. Windows and Canvases. Graphics Contexts. Drawing Lines. 37. How to Write Text in Windows. Writing Text. Fonts and Font Metrics. 38. How to Define Applets. Applets and The Applet Class. The Init Method. Testing Applets. 39. How to Access Applets From Web Browsers. Formatting Tags. Embedding Applets in HTML Files. Passing Arguments to Applets From HTML Files. Locating HTML Files With URL Addresses. 40. How to Use The Model--View Approach to Interface Design. The Observable Class. The Observer Interface. Notifying and Updating. 41. How to Use Choice Lists to Select Instances. Adding Elements to Choice Lists. Determining Which Element Has Been Selected. 42. How to Incorporate Images Into Applets. Toolkits and Media Trackers. Scaling and Drawing Images. 43. How to Use Threads to Implement Dynamic Applets. Apparently Simultaneous Computation. Processes and Multithreading. Starting, Stopping, Suspending, and Resuming Threads. Putting A Thread to Sleep. 44. How to Create Text Fields and Buttons. Text Fields. The Grid Layout. 45. How to Design Applets Using Layout Managers. Border, Grid, Flow, and Gridbag Layouts. The Role of Resize, Minimumsize, and Preferredsize. 46. How to Display Menus and File Dialog Windows. Menu Items, Menus, and Menu Bars. Accessing Files Via File Dialogs. Appendix A. Operator Precedence. Appendix B. The Meter Canvas. Appendix C. Applet Parameters. Appendix D. Fighting Flicker. Colophon. Index. 020149826XT04062001