Complete reference java unprotected

3,123 views
3,025 views

Published on

Published in: Technology, News & Politics
0 Comments
1 Like
Statistics
Notes
  • Be the first to comment

No Downloads
Views
Total views
3,123
On SlideShare
0
From Embeds
0
Number of Embeds
3
Actions
Shares
0
Downloads
112
Comments
0
Likes
1
Embeds 0
No embeds

No notes for slide

Complete reference java unprotected

  1. 1. Release Team[oR] 2001 [x] java
  2. 2. Java 2: The Complete Reference by Patrick Naughton and Herbert Schildt ISBN: 0072119764 Osborne/McGraw-Hill © 1999, 1108 pages This thorough reference reads like a helpful friend. Includes servlets, Swing, and more. Table of Contents Back CoverSynopsis by Rebecca RohanJava 2: The Complete Reference blends the expertise found in Java 1: TheComplete Reference with Java 2 topics such as "servlets" and "Swing." Asbefore, theres help with Java Beans and migrating from C++ to Java. Aspecial chapter gives networking basics and breaks out networking-relatedclasses. This book helps you master techniques by doing as well as reading.Projects include a multi-player word game with attention paid to networksecurity. The book is updated where appropriate throughout, and the rhythmof text, code, tables, and illustrations is superb. Its a valuable resource for thedeveloper who is elbow-deep in demanding projects.Table of ContentsJava 2 - The Complete Reference - 4Preface - 7Part l The Java LanguageChapter 1 - The Genesis of Java - 9Chapter 2 - An Overview of Java - 20Chapter 3 - Data Types, Variables, and Arrays - 36Chapter 4 - Operators - 57Chapter 5 - Control Statements - 75Chapter 6 - Introducing Classes - 94Chapter 7 - A Closer Look at Methods and Classes - 111Chapter 8 - Inheritance - 134Chapter 9 - Packages and Interfaces - 156hapter 10 - Exception Handling - 174Chapter 11 - Multithreaded Programming - 188Chapter 12 - I/O, Applets, and Other Topics - 214Part ll The Java LibraryChapter 13 - String Handling - 235Chapter 14 - Exploring java.lang - 255Chapter 15 - java.util Part 1: The Collections Framework - 297Chapter 16 - java.util Part 2: More Utility Classes - 343 -2-
  3. 3. Chapter 17 - Input/Output: Exploring java.io - 362Chapter 18 - Networking - 397Chapter 19 - The Applet Class - 426Chapter 20 - Event Handling - 443Chapter 21 - Introducing the AWT: Working with Windows, Graphics, and Text - 466Chapter 22 - Using AWT Controls, Layout Managers, and Menus - 499Chapter 23 - Images - 543Chapter 24 - Additional Packages - 568Part lll Software Development Using JavaChapter 25 - Java Beans - 582Chapter 26 - A Tour of Swing - 601Chapter 27 - Servlets - 616Chapter 28 - Migrating from C++ to Java - 641Part lV Applying JavaChapter 29 - The DynamicBillboard Applet - 659Chapter 30 - ImageMenu: An Image-Based Web Menu - 683Chapter 31 - The Lavatron Applet: A Sports Arena Display - 689Chapter 32 - Scrabblet: A Multiplayer Word Game - 696Appendix A - Using Java’s Documentation Comments - 739Back CoverMaster Java with the most comprehensive all-in-one tutorial/referenceavailable, now completely updated for the Java 2 specification. Topprogramming experts Patrick Naughton and Herbert Schildt show youeverything you need to know to develop, compile, debug and run Javaapplications and applets. Inside youll find a complete description of the Javalanguage, its class libraries, and its development environment. With cleardescriptions, hundreds of practical examples, and expert techniques, this is abook that no Java programmer should be without. With this book, youll: • Master the Java language and its core libraries • Create portable Java applets and applications • Fully utilize the Abstract Window Toolkit (AWT) • Supercharge your programs using multiple threads • Effectively apply Javas networking classes • Create servlets, draw images, and develop Java Beans • Migrate code from C++ to JavaPlus, youll find details on new Java 2 features, including: • The powerful collections framework • The Swing component set • The Java threading model • The numerous methods, classes, and interfaces found throughout the API About the AuthorsPatrick Naughton is currently the chief technology office for InfoseekCorporation. He is the founding member of the original Sun Microsystems -3-
  4. 4. project team that developed Java.Herbert Schildt is a leading authority on C and C++, an expert on Windows,and master at Java. He has written numerous best-selling books.Java 2: The Complete Reference Third Edition Patrick Naughton Herbert Schildt Osborne/McGraw-Hill 2600 Tenth Street Berkeley, California 94710 U.S.A. For information on translations or book distributors outside the U.S.A., or to arrange bulk purchase discounts for sales promotions, premiums, or fund-raisers, please contact Osborne/McGraw-Hill at the above address. Copyright © 1999 by The McGraw-Hill Companies. All rights reserved. Printed in the United States of America. Except as permitted under the Copyright Act of 1976, no part of this publication may be reproduced or distributed in any form or by any means, or stored in a database or retrieval system, without the prior written permission of the publisher, with the exception that the program listings may be entered, stored, and executed in a computer system, but they may not be reproduced for publication. 1234567890 AGM AGM 90198765432109 ISBN 0-07-211976-4 Publisher Brandon A. Nordin Associate Publisher/Editor-in-Chief Scott Rogers Acquisitions Editor Megg Bonar Project Editor Janet Walden Editorial Assistant Stephane Thomas Technical Editor Tom Feng -4-
  5. 5. Copy Editor William McManus Proofreader Emily K. Wolman Indexer Sheryl Schildt Computer Designer Michelle Galicia Jani Beckwith Ann Sellers Illustrator Brian Wells Beth Young Information has been obtained by Osborne/McGraw-Hill from sources believed to be reliable. However, because of the possibility of human or mechanical error by our sources, Osborne/McGraw-Hill, or others, Osborne/McGraw-Hill does not guarantee the accuracy, adequacy, or completeness of any information and is not responsible for any errors or omissions or the results obtained from use of such information. About the Authors Patrick Naughton started consulting as a software engineer in 1982, paying his way through school and gaining a trial-by-fire perspective on the PC industry as it grew from its infancy. After extensive experience with the X Window System from MIT, he joined Sun Microsystems window systems group in 1988. In late 1990, Naughton started a secret project called "Green" in SunLabs. This small project intended to create a completely new platform for software development that would solve many of the problems in existing systems. The most significant technology to come out of the Green project was Java. Naughton was instrumental in the creation and evolution of Java, from its inception through to its revolutionary transition into the language of the Internet. Naughton is currently the executive vice president of products for Infoseek Corporation, and is the leader of the team that creates the groundbreaking GO Network™. Prior to working with Infoseek, he was president and chief technology officer of Paul Allens Starwave Corporation, where he led the development of platform strategies, systems software, applications, and tools to publish a suite of award-winning online services, including ESPN.com, ABCNEWS.com, Mr. Showbiz, NBA.com, and NFL.com, among others. Naughton is the author of The Java Handbook and coauthor of Java 1.1: The Complete Reference, both best-sellers from Osborne/McGraw-Hill. He holds a B.S. in computer science from Clarkson University. Herbert Schildt is the worlds leading programming author. His books have sold more than two million copies worldwide and have been translated into all major foreign languages. Herb is author of the best-sellers C++: The Complete Reference, C: The Complete Reference, Java Programmers Reference, Teach Yourself C, Teach Yourself C++, C++ from the Ground Up, Windows 98 Programming from the Ground Up, and STL Programming from the Ground Up. He is also a coauthor of C/C++ Annotated Archives. Herb is president of Universal Computing Laboratories, a software consulting firm in Mahomet, Illinois. He holds a masters degree in computer science from the University of Illinois.Special Thanks -5-
  6. 6. Special thanks go to Joe ONeil for his help in preparing the third edition of this book. In addition to handling the updating required by the new Java 2 specification, Joe also provided the initial drafts for Chapters 24, 25, 26, and 27. As always, his efforts are appreciated.Acknowledgments Writing my first book, The Java Handbook, was a spiritual experience—bringing closure to my five years of effort on the Java project. It reads more like a narrative tour through Java than a "complete reference." Not all of the Java library classes were covered, and not every method in each class was listed. Culminating with the history chapter, "The Long Strange Trip to Java," the book provided an outlet for my personal opinions about how the language turned out. This book is different. It presents a balanced, objective, and comprehensive view of Java. The heroics of the people who made this language happen are largely undocumented. The press tends to focus too narrowly in order to make for a clean story. The success of this language is not due to any single person, but to the combined successes and failings of a group of dedicated and inspirational individuals—including James Gosling, Arthur van Hoff, Jonathan Payne, Chris Warth, Tim Lindholm, Frank Yellin, Sami Shaio, Patrick Chan, Kim Polese, Richard Tuck, Eugene Kuerner, Bill Joy, and many more. My respect for what that team accomplished grows with each passing day and each Java class I write. The Internet is a strange place to work. For this books first edition, I spent six months working closely with a man Ive never met. Herb Schildt wrote a wonderful book, C++: The Complete Reference, about a very difficult language. When it became clear that programmers needed a combination of what I offered in The Java Handbook and Herbs book, the solution was simple. We teamed up to provide the best of both worlds. Herb understands how to present difficult concepts in a way that neither insults the experienced programmer nor leaves the beginner behind. His stamina for writing down every little detail combined with my understanding of how those details came about has made for a book we think you will all enjoy. Weve updated this book for Java 2 so that it remains current and continues to deliver a solid reference in a proven format. Herb has done most of the hard work on this third edition. My main goal was to include complete examples of excellent Java programming. To avoid presenting a single biased view about how to write Java, I also used some of my friends excellent applets and they deserve credit for their work here: • Robert Temple is a gifted Java programmer who creates amazing applets with almost no download time. I saw his code on the net and sent him e-mail to offer him a job, but coincidentally, he had found the job listing on the web and had already scheduled an interview trip. His DynamicBillboard applet, which we examine in Chapter 29, is full of nonobvious performance tricks, which renewed my faith in Java the first time I saw it. • David LaVallée (a.k.a. Scout) is one of four people who were writing Java code in 1991. His ImageMenu and Lavatron applets in Chapters 30 and 31 are classic Scout design. Famous for his "baubles and trinkets," he always brings a creative design angle to his applets. • David Geller is a longtime Windows programmer and author who has a keen eye for developer tools. His insight and contributions on development environments were invaluable. • Johanna Carr remains the smartest nonprogrammer in the world when it comes to software systems and languages. She diligently read and commented on every page of this book, at least twice. If Johanna cant understand it, it is probably poorly written. -6-
  7. 7. Thanks also go to Matthew Naythons, who looks out for my best interests so I dont haveto.And, to Kenna Moser, who continues to support my aspirations with love,encouragement, and great double lattés.PATRICK J. NAUGHTONPrefaceProgramming languages, paradigms, and practices dont stand still very long. It oftenseems that the methods and techniques we applied yesterday are out-of-date today. Ofcourse, this rapid rate of change is also one of the things that keeps programmingexciting. There is always something new on the horizon.Perhaps no language better exemplifies the preceding statements than Java. In thespace of just a few years, Java grew from a concept into one of the worlds dominantcomputer languages. Moreover, during the same short period of time, Java has gonethrough two major revisions. The first occurred when 1.1 was released. The change inthe minor revision number from 1.0 to 1.1 belies the significance of the 1.1 specification.For example, Java 1.1 fundamentally altered the way events were handled, added suchfeatures as Java Beans, and enhanced the API.The second major revision, Java 2, is the subject of this book. Java 2 keeps all of thefunctionality provided by Java 1.1, but adds a substantial amount of new and innovativefeatures. For example, it adds the collections framework, Swing, a new threading model,and numerous API methods and classes. In fact, so many new features have been addedthat it is not possible to discuss them all in this book.In order to keep pace with Java, this book, too, has gone through rapid revision cycles.The original version of this book covered Java 1.0. The second edition covered 1.1. This,the third edition, covers Java 2. The time from the first edition to the third is less than twoand one half years! But then, this book is about Java—and Java moves fast!A Book for All ProgrammersTo use this book does not require any previous programming experience. If, however, youcome from a C/C++ background, then you will be able to advance a bit more rapidly. Asmost readers will know, Java is similar, in form and spirit, to C/C++. Thus, knowledge ofthose languages helps, but is not necessary. Even if you have never programmed before,you can learn to program in Java using this book.Whats InsideThis book covers all aspects of the Java programming language. Part I presents an in-depth tutorial of the Java language. It begins with the basics, including such things asdata types, control statements, and classes. Part I also discusses Javas exception-handling mechanism, multithreading subsystem, packages, and interfaces.Part II examines the standard Java library. As you will learn, much of Javas power isfound in its library. Topics include strings, I/O, networking, the standard utilities, thecollections framework, applets, GUI-based controls, and imaging.Part III looks at some issues relating to the Java development environment, including anoverview of Java Beans, Swing, and servlets.Part IV presents a number of high-powered Java applets, which serve as extendedexamples of the way Java can be applied. The final applet, called Scrabblet, is a complete, -7-
  8. 8. multiuser networked game. It shows how to handle some of the toughest issues involved in Web-based programming.Whats New in the Third Edition The major differences between this and the previous editions of this book involve those features added by Java 2. These include such things as the collections framework, Swing, and the changes to the way multithreading is handled. However, there are also many smaller changes that are sprinkled throughout the Java API. Another new item added to the book is the chapter on servlets, which are small programs that extend a Web servers functionality. I think that you will find this to be a particularly interesting addition.A Team Effort I have been writing about programming for many years now. I seldom work with a coauthor. However, because of the special nature of this book, I teamed up with Patrick Naughton, one of the creators of Java. Patricks insights, expertise, and energy contributed greatly to the success of this project. Because of Patricks detailed knowledge of the Java language, its design, and implementation, there are tips and techniques found in this book that are difficult (if not impossible) to find elsewhere. HERBERT SCHILDT Part l: The Java Language Chapter List Chapter The Genesis of Java 1: Chapter An Overview of Java 2: Chapter Data Types, Variables, and Arrays 3: Chapter Operators 4: Chapter Control Statements 5: Chapter Introducing Classes 6: Chapter A Closer Look at Methods and Classes 7: Chapter Inheritance 8: Chapter Packages and Interfaces 9: -8-
  9. 9. Chapter Exception Handling 10: Chapter Multithreaded Programming 11: Chapter I/O, Applets, and Other Topics 12:Chapter 1: The Genesis of Java Overview When the chronicle of computer languages is written, the following will be said: B led to C, C evolved into C++, and C++ set the stage for Java. To understand Java is to understand the reasons that drove its creation, the forces that shaped it, and the legacy that it inherits. Like the successful computer languages that came before, Java is a blend of the best elements of its rich heritage combined with the innovative concepts required by its unique environment. While the remaining chapters of this book describe the practical aspects of Java—including its syntax, libraries, and applications—in this chapter, you will learn how and why Java came about, and what makes it so important. Although Java has become inseparably linked with the online environment of the Internet, it is important to remember that Java is first and foremost a programming language. Computer language innovation and development occurs for two fundamental reasons: • To adapt to changing environments and uses • To implement refinements and improvements in the art of programming As you will see, the creation of Java was driven by both elements in nearly equal measure.Javas Lineage Java is related to C++, which is a direct descendent of C. Much of the character of Java is inherited from these two languages. From C, Java derives its syntax. Many of Javas object-oriented features were influenced by C++. In fact, several of Javas defining characteristics come from—or are responses to—its predecessors. Moreover, the creation of Java was deeply rooted in the process of refinement and adaptation that has been occurring in computer programming languages for the past three decades. For these reasons, this section reviews the sequence of events and forces that led up to Java. As you will see, each innovation in language design was driven by the need to solve a fundamental problem that the preceding languages could not solve. Java is no exception. The Birth of Modern Programming: C The C language shook the computer world. Its impact should not be underestimated, because it fundamentally changed the way programming was approached and thought about. The creation of C was a direct result of the need for a structured, efficient, high- level language that could replace assembly code when creating systems programs. As you probably know, when a computer language is designed, trade-offs are often made, such as the following: • Ease-of-use versus power -9-
  10. 10. • Safety versus efficiency• Rigidity versus extensibilityPrior to C, programmers usually had to choose between languages that optimized oneset of traits or the other. For example, although FORTRAN could be used to write fairlyefficient programs for scientific applications, it was not very good for systems code. Andwhile BASIC was easy to learn, it wasnt very powerful, and its lack of structure made itsusefulness questionable for large programs. Assembly language can be used to producehighly efficient programs, but it is not easy to learn or use effectively. Further, debuggingassembly code can be quite difficult.Another compounding problem was that early computer languages such as BASIC,COBOL, and FORTRAN were not designed around structured principles. Instead, theyrelied upon the GOTO as a primary means of program control. As a result, programswritten using these languages tended to produce "spaghetti code"—a mass of tangledjumps and conditional branches that make a program virtually impossible to understand.While languages like Pascal are structured, they were not designed for efficiency, andfailed to include certain features necessary to make them applicable to a wide range ofprograms. (Specifically, given the standard dialects of Pascal available at the time, it wasnot practical to consider using Pascal for systems-level code.)So, just prior to the invention of C, no one language had reconciled the conflictingattributes that had dogged earlier efforts. Yet the need for such a language was pressing.By the early 1970s, the computer revolution was beginning to take hold, and the demandfor software was rapidly outpacing programmers ability to produce it. A great deal ofeffort was being expended in academic circles in an attempt to create a better computerlanguage. But, and perhaps most importantly, a secondary force was beginning to be felt.Computer hardware was finally becoming common enough that a critical mass was beingreached. No longer were computers kept behind locked doors. For the first time,programmers were gaining virtually unlimited access to their machines. This allowed thefreedom to experiment. It also allowed programmers to begin to create their own tools.On the eve of Cs creation, the stage was set for a quantum leap forward in computerlanguages.Invented and first implemented by Dennis Ritchie on a DEC PDP-11 running the UNIXoperating system, C was the result of a development process that started with an olderlanguage called BCPL, developed by Martin Richards. BCPL influenced a languagecalled B, invented by Ken Thompson, which led to the development of C in the 1970s.For many years, the de facto standard for C was the one supplied with the UNIXoperating system and described in The C Programming Language by Brian Kernighanand Dennis Ritchie (Prentice-Hall, 1978). C was formally standardized in December1989, when the American National Standards Institute (ANSI) standard for C wasadopted.The creation of C is considered by many to have marked the beginning of the modernage of computer languages. It successfully synthesized the conflicting attributes that hadso troubled earlier languages. The result was a powerful, efficient, structured languagethat was relatively easy to learn. It also included one other, nearly intangible aspect: itwas a programmers language. Prior to the invention of C, computer languages weregenerally designed either as academic exercises or by bureaucratic committees. C isdifferent. It was designed, implemented, and developed by real, working programmers,reflecting the way that they approached the job of programming. Its features were honed,tested, thought about, and rethought by the people who actually used the language. Theresult was a language that programmers liked to use. Indeed, C quickly attracted manyfollowers who had a near-religious zeal for it. As such, it found wide and rapidacceptance in the programmer community. In short, C is a language designed by and forprogrammers. As you will see, Java has inherited this legacy.The Need for C++ - 10 -
  11. 11. During the late 1970s and early 1980s, C became the dominant computer programminglanguage, and it is still widely used today. Since C is a successful and useful language,you might ask why a need for something else existed. The answer is complexity.Throughout the history of programming, the increasing complexity of programs has driventhe need for better ways to manage that complexity. C++ is a response to that need. Tobetter understand why managing program complexity is fundamental to the creation ofC++, consider the following.Approaches to programming have changed dramatically since the invention of thecomputer. For example, when computers were first invented, programming was done bymanually toggling in the binary machine instructions by use of the front panel. As long asprograms were just a few hundred instructions long, this approach worked. As programsgrew, assembly language was invented so that a programmer could deal with larger,increasingly complex programs by using symbolic representations of the machineinstructions. As programs continued to grow, high-level languages were introduced thatgave the programmer more tools with which to handle complexity.The first widespread language was, of course, FORTRAN. While FORTRAN was animpressive first step, it is hardly a language that encourages clear and easy-to-understand programs. The 1960s gave birth to structured programming. This is themethod of programming championed by languages such as C. The use of structuredlanguages enabled programmers to write, for the first time, moderately complexprograms fairly easily. However, even with structured programming methods, once aproject reaches a certain size, its complexity exceeds what a programmer can manage.By the early 1980s, many projects were pushing the structured approach past its limits.To solve this problem, a new way to program was invented, called object-orientedprogramming (OOP). Object-oriented programming is discussed in detail later in thisbook, but here is a brief definition: OOP is a programming methodology that helpsorganize complex programs through the use of inheritance, encapsulation, andpolymorphism.In the final analysis, although C is one of the worlds great programming languages, thereis a limit to its ability to handle complexity. Once a program exceeds somewhere between25,000 and 100,000 lines of code, it becomes so complex that it is difficult to grasp as atotality. C++ allows this barrier to be broken, and helps the programmer comprehend andmanage larger programs.C++ was invented by Bjarne Stroustrup in 1979, while he was working at BellLaboratories in Murray Hill, New Jersey. Stroustrup initially called the new language "Cwith Classes." However, in 1983, the name was changed to C++. C++ extends C byadding object-oriented features. Because C++ is built upon the foundation of C, itincludes all of Cs features, attributes, and benefits. This is a crucial reason for thesuccess of C++ as a language. The invention of C++ was not an attempt to create acompletely new programming language. Instead, it was an enhancement to an alreadyhighly successful one. C++ was standardized in November 1997, and an ANSI/ISOstandard for C++ is now available.The Stage Is Set for JavaBy the end of the 1980s and the early 1990s, object-oriented programming using C++ tookhold. Indeed, for a brief moment it seemed as if programmers had finally found the perfectlanguage. Because C++ blended the high efficiency and stylistic elements of C with theobject-oriented paradigm, it was a language that could be used to create a wide range ofprograms. However, just as in the past, forces were brewing that would, once again, drivecomputer language evolution forward. Within a few years, the World Wide Web and theInternet would reach critical mass. This event would precipitate another revolution inprogramming.The Creation of Java - 11 -
  12. 12. Java was conceived by James Gosling, Patrick Naughton, Chris Warth, Ed Frank, andMike Sheridan at Sun Microsystems, Inc. in 1991. It took 18 months to develop the firstworking version. This language was initially called "Oak" but was renamed "Java" in1995. Between the initial implementation of Oak in the fall of 1992 and the publicannouncement of Java in the spring of 1995, many more people contributed to the designand evolution of the language. Bill Joy, Arthur van Hoff, Jonathan Payne, Frank Yellin,and Tim Lindholm were key contributors to the maturing of the original prototype.Somewhat surprisingly, the original impetus for Java was not the Internet! Instead, theprimary motivation was the need for a platform-independent (that is, architecture- neutral)language that could be used to create software to be embedded in various consumerelectronic devices, such as microwave ovens and remote controls. As you can probablyguess, many different types of CPUs are used as controllers. The trouble with C and C++(and most other languages) is that they are designed to be compiled for a specific target.Although it is possible to compile a C++ program for just about any type of CPU, to do sorequires a full C++ compiler targeted for that CPU. The problem is that compilers areexpensive and time-consuming to create. An easier—and more cost-efficient—solutionwas needed. In an attempt to find such a solution, Gosling and others began work on aportable, platform-independent language that could be used to produce code that wouldrun on a variety of CPUs under differing environments. This effort ultimately led to thecreation of Java.About the time that the details of Java were being worked out, a second, and ultimatelymore important, factor was emerging that would play a crucial role in the future of Java.This second force was, of course, the World Wide Web. Had the Web not taken shape atabout the same time that Java was being implemented, Java might have remained auseful but obscure language for programming consumer electronics. However, with theemergence of the World Wide Web, Java was propelled to the forefront of computerlanguage design, because the Web, too, demanded portable programs.Most programmers learn early in their careers that portable programs are as elusive asthey are desirable. While the quest for a way to create efficient, portable (platform-independent) programs is nearly as old as the discipline of programming itself, it hadtaken a back seat to other, more pressing problems. Further, because much of thecomputer world had divided itself into the three competing camps of Intel, Macintosh, andUNIX, most programmers stayed within their fortified boundaries, and the urgent need forportable code was reduced. However, with the advent of the Internet and the Web, theold problem of portability returned with a vengeance. After all, the Internet consists of adiverse, distributed universe populated with many types of computers, operating systems,and CPUs. Even though many types of platforms are attached to the Internet, userswould like them all to be able to run the same program. What was once an irritating butlow-priority problem had become a high-profile necessity.By 1993, it became obvious to members of the Java design team that the problems ofportability frequently encountered when creating code for embedded controllers are alsofound when attempting to create code for the Internet. In fact, the same problem thatJava was initially designed to solve on a small scale could also be applied to the Interneton a large scale. This realization caused the focus of Java to switch from consumerelectronics to Internet programming. So, while the desire for an architecture-neutralprogramming language provided the initial spark, the Internet ultimately led to Javaslarge-scale success.As mentioned earlier, Java derives much of its character from C and C++. This is byintent. The Java designers knew that using the familiar syntax of C and echoing theobject-oriented features of C++ would make their language appealing to the legions ofexperienced C/C++ programmers. In addition to the surface similarities, Java sharessome of the other attributes that helped make C and C++ successful. First, Java wasdesigned, tested, and refined by real, working programmers. It is a language grounded inthe needs and experiences of the people who devised it. Thus, Java is also aprogrammers language. Second, Java is cohesive and logically consistent. Third, exceptfor those constraints imposed by the Internet environment, Java gives you, the - 12 -
  13. 13. programmer, full control. If you program well, your programs reflect it. If you program poorly, your programs reflect that, too. Put differently, Java is not a language with training wheels. It is a language for professional programmers. Because of the similarities between Java and C++, it is tempting to think of Java as simply the "Internet version of C++." However, to do so would be a large mistake. Java has significant practical and philosophical differences. While it is true that Java was influenced by C++, it is not an enhanced version of C++. For example, Java is neither upwardly nor downwardly compatible with C++. Of course, the similarities with C++ are significant, and if you are a C++ programmer, then you will feel right at home with Java. One other point: Java was not designed to replace C++. Java was designed to solve a certain set of problems. C++ was designed to solve a different set of problems. Both will coexist for many years to come. As mentioned at the start of this chapter, computer languages evolve for two reasons: to adapt to changes in environment and to implement advances in the art of programming. The environmental change that prompted Java was the need for platform-independent programs destined for distribution on the Internet. However, Java also embodies changes in the way that people approach the writing of programs. Specifically, Java enhances and refines the object-oriented paradigm used by C++. Thus, Java is not a language that exists in isolation. Rather, it is the current instance of an ongoing process begun many years ago. This fact alone is enough to ensure Java a place in computer language history. Java is to Internet programming what C was to systems programming: a revolutionary force that will change the world.Why Java Is Important to the Internet The Internet helped catapult Java to the forefront of programming, and Java, in turn, has had a profound effect on the Internet. The reason for this is quite simple: Java expands the universe of objects that can move about freely in cyberspace. In a network, two very broad categories of objects are transmitted between the server and your personal computer: passive information and dynamic, active programs. For example, when you read your e-mail, you are viewing passive data. Even when you download a program, the programs code is still only passive data until you execute it. However, a second type of object can be transmitted to your computer: a dynamic, self-executing program. Such a program is an active agent on the client computer, yet is initiated by the server. For example, a program might be provided by the server to display properly the data that the server is sending. As desirable as dynamic, networked programs are, they also present serious problems in the areas of security and portability. Prior to Java, cyberspace was effectively closed to half the entities that now live there. As you will see, Java addresses those concerns and, by doing so, has opened the door to an exciting new form of program: the applet. Java Applets and Applications Java can be used to create two types of programs: applications and applets. An application is a program that runs on your computer, under the operating system of that computer. That is, an application created by Java is more or less like one created using C or C++. When used to create applications, Java is not much different from any other computer language. Rather, it is Javas ability to create applets that makes it important. An applet is an application designed to be transmitted over the Internet and executed by a Java-compatible Web browser. An applet is actually a tiny Java program, dynamically downloaded across the network, just like an image, sound file, or video clip. The important difference is that an applet is an intelligent program, not just an animation or media file. In other words, an applet is a program that can react to user input and dynamically change—not just run the same animation or sound over and over. As exciting as applets are, they would be nothing more than wishful thinking if Java were not able to address the two fundamental problems associated with them: security and portability. Before continuing, lets define what these two terms mean relative to the - 13 -
  14. 14. Internet. Security As you are likely aware, every time that you download a "normal" program, you are risking a viral infection. Prior to Java, most users did not download executable programs frequently, and those who did scanned them for viruses prior to execution. Even so, most users still worried about the possibility of infecting their systems with a virus. In addition to viruses, another type of malicious program exists that must be guarded against. This type of program can gather private information, such as credit card numbers, bank account balances, and passwords, by searching the contents of your computers local file system. Java answers both of these concerns by providing a "firewall" between a networked application and your computer. When you use a Java-compatible Web browser, you can safely download Java applets without fear of viral infection or malicious intent. Java achieves this protection by confining a Java program to the Java execution environment and not allowing it access to other parts of the computer. (You will see how this is accomplished shortly.) The ability to download applets with confidence that no harm will be done and that no security will be breached is considered by many to be the single most important aspect of Java. Portability As discussed earlier, many types of computers and operating systems are in use throughout the world—and many are connected to the Internet. For programs to be dynamically downloaded to all the various types of platforms connected to the Internet, some means of generating portable executable code is needed. As you will soon see, the same mechanism that helps ensure security also helps create portability. Indeed, Javas solution to these two problems is both elegant and efficient.Javas Magic: The Bytecode The key that allows Java to solve both the security and the portability problems just described is that the output of a Java compiler is not executable code. Rather, it is bytecode. Bytecode is a highly optimized set of instructions designed to be executed by the Java run-time system, which is called the Java Virtual Machine (JVM). That is, in its standard form, the JVM is an interpreter for bytecode. This may come as a bit of a surprise. As you know, C++ is compiled to executable code. In fact, most modern languages are designed to be compiled, not interpreted—mostly because of performance concerns. However, the fact that a Java program is executed by the JVM helps solve the major problems associated with downloading programs over the Internet. Here is why. Translating a Java program into bytecode helps makes it much easier to run a program in a wide variety of environments. The reason is straightforward: only the JVM needs to be implemented for each platform. Once the run-time package exists for a given system, any Java program can run on it. Remember, although the details of the JVM will differ from platform to platform, all interpret the same Java bytecode. If a Java program were compiled to native code, then different versions of the same program would have to exist for each type of CPU connected to the Internet. This is, of course, not a feasible solution. Thus, the interpretation of bytecode is the easiest way to create truly portable programs. The fact that a Java program is interpreted also helps to make it secure. Because the execution of every Java program is under the control of the JVM, the JVM can contain the program and prevent it from generating side effects outside of the system. As you will see, safety is also enhanced by certain restrictions that exist in the Java language. When a program is interpreted, it generally runs substantially slower than it would run if compiled to executable code. However, with Java, the differential between the two is not so great. The use of bytecode enables the Java run-time system to execute programs much faster than you might expect. - 14 -
  15. 15. Although Java was designed for interpretation, there is technically nothing about Java that prevents on-the-fly compilation of bytecode into native code. Along these lines, Sun has just completed its Just In Time (JIT) compiler for bytecode, which is included in the Java 2 release. When the JIT compiler is part of the JVM, it compiles bytecode into executable code in real time, on a piece-by-piece, demand basis. It is important to understand that it is not possible to compile an entire Java program into executable code all at once, because Java performs various run-time checks that can be done only at run time. Instead, the JIT compiles code as it is needed, during execution. However, the just-in-time approach still yields a significant performance boost. Even when dynamic compilation is applied to bytecode, the portability and safety features still apply, because the run-time system (which performs the compilation) still is in charge of the execution environment. Whether your Java program is actually interpreted in the traditional way or compiled on-the-fly, its functionality is the same.The Java Buzzwords No discussion of the genesis of Java is complete without a look at the Java buzzwords. Although the fundamental forces that necessitated the invention of Java are portability and security, other factors also played an important role in molding the final form of the language. The key considerations were summed up by the Java team in the following list of buzzwords: • Simple • Secure • Portable • Object-oriented • Robust • Multithreaded • Architecture-neutral • Interpreted • High performance • Distributed • Dynamic Two of these buzzwords have already been discussed: secure and portable. Lets examine what each of the others implies. Simple Java was designed to be easy for the professional programmer to learn and use effectively. Assuming that you have some programming experience, you will not find Java hard to master. If you already understand the basic concepts of object-oriented programming, learning Java will be even easier. Best of all, if you are an experienced C++ programmer, moving to Java will require very little effort. Because Java inherits the C/C++ syntax and many of the object-oriented features of C++, most programmers have little trouble learning Java. Also, some of the more confusing concepts from C++ are - 15 -
  16. 16. either left out of Java or implemented in a cleaner, more approachable manner.Beyond its similarities with C/C++, Java has another attribute that makes it easy to learn:it makes an effort not to have surprising features. In Java, there are a small number ofclearly defined ways to accomplish a given task.Object-OrientedAlthough influenced by its predecessors, Java was not designed to be source-codecompatible with any other language. This allowed the Java team the freedom to designwith a blank slate. One outcome of this was a clean, usable, pragmatic approach toobjects. Borrowing liberally from many seminal object-software environments of the lastfew decades, Java manages to strike a balance between the purists "everything is anobject" paradigm and the pragmatists "stay out of my way" model. The object model inJava is simple and easy to extend, while simple types, such as integers, are kept as high-performance nonobjects.RobustThe multiplatformed environment of the Web places extraordinary demands on aprogram, because the program must execute reliably in a variety of systems. Thus, theability to create robust programs was given a high priority in the design of Java. To gainreliability, Java restricts you in a few key areas, to force you to find your mistakes early inprogram development. At the same time, Java frees you from having to worry aboutmany of the most common causes of programming errors. Because Java is a strictlytyped language, it checks your code at compile time. However, it also checks your codeat run time. In fact, many hard-to-track-down bugs that often turn up in hard-to-reproducerun-time situations are simply impossible to create in Java. Knowing that what you havewritten will behave in a predictable way under diverse conditions is a key feature of Java.To better understand how Java is robust, consider two of the main reasons for programfailure: memory management mistakes and mishandled exceptional conditions (that is,run-time errors). Memory management can be a difficult, tedious task in traditionalprogramming environments. For example, in C/C++, the programmer must manuallyallocate and free all dynamic memory. This sometimes leads to problems, becauseprogrammers will either forget to free memory that has been previously allocated or,worse, try to free some memory that another part of their code is still using. Java virtuallyeliminates these problems by managing memory allocation and deallocation for you. (Infact, deallocation is completely automatic, because Java provides garbage collection forunused objects.) Exceptional conditions in traditional environments often arise insituations such as division by zero or "file not found," and they must be managed withclumsy and hard-to-read constructs. Java helps in this area by providing object-orientedexception handling. In a well-written Java program, all run-time errors can—and should—be managed by your program.MultithreadedJava was designed to meet the real-world requirement of creating interactive, networkedprograms. To accomplish this, Java supports multithreaded programming, which allowsyou to write programs that do many things simultaneously. The Java run-time systemcomes with an elegant yet sophisticated solution for multiprocess synchronization thatenables you to construct smoothly running interactive systems. Javas easy-to-useapproach to multithreading allows you to think about the specific behavior of yourprogram, not the multitasking subsystem.Architecture-NeutralA central issue for the Java designers was that of code longevity and portability. One ofthe main problems facing programmers is that no guarantee exists that if you write a - 16 -
  17. 17. program today, it will run tomorrow—even on the same machine. Operating systemupgrades, processor upgrades, and changes in core system resources can all combine tomake a program malfunction. The Java designers made several hard decisions in theJava language and the Java Virtual Machine in an attempt to alter this situation. Theirgoal was "write once; run anywhere, any time, forever." To a great extent, this goal wasaccomplished.Interpreted and High PerformanceAs described earlier, Java enables the creation of cross-platform programs by compilinginto an intermediate representation called Java bytecode. This code can be interpretedon any system that provides a Java Virtual Machine. Most previous attempts at cross-platform solutions have done so at the expense of performance. Other interpretedsystems, such as BASIC, Tcl, and PERL, suffer from almost insurmountable performancedeficits. Java, however, was designed to perform well on very low-power CPUs. Asexplained earlier, while it is true that Java was engineered for interpretation, the Javabytecode was carefully designed so that it would be easy to translate directly into nativemachine code for very high performance by using a just-in-time compiler. Java run-timesystems that provide this feature lose none of the benefits of the platform-independentcode. "High-performance cross-platform" is no longer an oxymoron.DistributedJava is designed for the distributed environment of the Internet, because it handlesTCP/IP protocols. In fact, accessing a resource using a URL is not much different fromaccessing a file. The original version of Java (Oak) included features for intra-address-space messaging. This allowed objects on two different computers to execute proceduresremotely. Java has recently revived these interfaces in a package called Remote MethodInvocation (RMI). This feature brings an unparalleled level of abstraction to client/serverprogramming.DynamicJava programs carry with them substantial amounts of run-time type information that isused to verify and resolve accesses to objects at run time. This makes it possible todynamically link code in a safe and expedient manner. This is crucial to the robustness ofthe applet environment, in which small fragments of bytecode may be dynamically updatedon a running system.The Continuing RevolutionThe initial release of Java was nothing short of revolutionary, but it did not mark the endof Javas era of rapid innovation. Unlike most other software systems that usually settleinto a pattern of small, incremental improvements, Java continued to evolve at anexplosive pace. Soon after the release of Java 1.0, the designers of Java had alreadycreated Java 1.1. The features added by Java 1.1 were more significant and substantialthan the increase in the minor revision number would have you think. Java 1.1 addedmany new library elements, redefined the way events are handled by applets, andreconfigured many features of the 1.0 library. It also deprecated (rendered obsolete)several features originally defined by Java 1.0. Thus, Java 1.1 both added and subtractedattributes from its original specification. Continuing in this evolution, Java 2 also adds andsubtracts features.While all languages change over time, changes to Java take on an extra importance,because older browsers will not be able to execute code that uses a new feature. For thisreason, it is good to have a general understanding of when various changes have takenplace. With this in mind, the next section takes a brief look at the evolution of Java sinceits original 1.0 specification. - 17 -
  18. 18. Features Added by 1.1Version 1.1 added some important elements to Java. Most of the additions occurred inthe Java library. However, a few new language features were also included. Here is a listof the most important features added by 1.1:• Java Beans, which are software components that are written in Java.• Serialization, which allows you to save and restore the state of an object.• Remote Method Invocation (RMI), which allows a Java object to invoke the methods of another Java object that is located on a different machine. This is an important facility for building distributed applications.• Java Database Connectivity (JDBC), which allows programs to access SQL databases from many different vendors.• The Java Native Interface (JNI), which provides a new way for your programs to interface with code libraries written in other languages.• Reflection, which is the process of determining the fields, constructors, and methods of a Java object at run time.• Various security features, such as digital signatures, message digests, access control lists, and key generation.• Built-in support for 16-bit character streams that handle Unicode characters.• Significant changes to event handling that improve the way in which events generated by graphical user interface (GUI) components are handled.• Inner classes, which allow one class to be defined within another.Features Deprecated by 1.1As just mentioned, Java 1.1 deprecated many earlier library elements. For example, mostof the original Date class was deprecated. However, the deprecated features did not goaway. Instead, they were replaced with updated alternatives. In general, deprecated 1.0features are still available in Java to support legacy code, but they should not be used bynew applications. This book still describes a few of the more important deprecated 1.0library elements, for the sake of programmers older code.Features Added by 2Building upon 1.1, Java 2 adds many important new features. Here is a partial list:• Swing is a set of user interface components that is implemented entirely in Java. You can use a look and feel that is either specific to a particular operating system or uniform across operating systems. You can also design your own look and feel.• Collections are groups of objects. Java 2 provides several types of collections, such as linked lists, dynamic arrays, and hash tablefsections, for your use. Collections offer a new way to solve several common programming problems.• More flexible security mechanisms are now available for Java programs. Policy files can define the permissions for code from various sources. These determine, for example, whether a particular file or directory may be accessed, or whether a - 18 -
  19. 19. connection can be established to a specific host and port. • Digital certificates provide a mechanism to establish the identity of a user. You may think of them as electronic passports. Java programs can parse and use certificates to enforce security policies. • Various security tools are available that enable you to create and store cryptographic keys and digital certificates, sign Java Archive (JAR) files, and check the signature of a JAR file. • The Accessibility library provides features that make it easier for people with sight impairments or other disabilities to work with computers. Of course, these capabilities can be useful for any user. • The Java 2D library provides advanced features for working with shapes, images, and text. • Drag-and-drop capabilities allow you to transfer data within or between applications. • Text components can now receive Japanese, Chinese, and Korean characters from the keyboard. This is done by using a sequence of keystrokes to represent one character. • You can now play back WAV, AIFF, AU, MIDI, and RMF audio files. • The Common Object Request Broker Architecture (CORBA) defines an Object Request Broker (ORB) and an Interface Definition Language (IDL). Java 2 includes an ORB and an idltojava compiler. The latter generates code from an IDL specification. • Performance improvements have been made in several areas. A Just-In-Time (JIT) compiler is included in the JDK. • Many browsers include a Java Virtual Machine that is used to execute applets. Unfortunately, browser JVMs typically do not include the latest Java features. The Java Plug-In solves this problem. It directs a browser to use a Java Runtime Environment (JRE) rather than the browsers JVM. The JRE is a subset of the JDK. It does not include the tools and classes that are used in a development environment. • Various tools such as javac, java, and javadoc have been enhanced. Debugger and profiler interfaces for the JVM are available. Features Deprecated by 2 Although not as extensive as the deprecations experienced between 1.0 and 1.1, some features of Java 1.1 are deprecated by Java 2. For example, the suspend( ), resume( ), and stop( ) methods of the Thread class should not be used in new code. Throughout this book, deprecated features are pointed out and their Java 2 alternatives are described. This will be helpful to any programmer charged with updating Java 1.1 code.Java Is Not an Enhanced HTML Before moving on, it is necessary to dispel a common misunderstanding. Because Java is used in the creation of Web pages, newcomers sometimes confuse Java with Hypertext Markup Language (HTML) or think that Java is simply some enhancement to HTML. Fortunately, these are misconceptions. HTML is, in essence, a means of defining the logical organization of information and providing links, called hypertext links, to related information. As you probably know, a hypertext link (also called a hyperlink) is a link to another hypertext document, which may exist either locally or elsewhere on the Web. The defining element of a hypertext document is that it can be read in a nonlinear - 19 -
  20. 20. fashion, with the user pursuing various paths by choosing hypertext links to other, relateddocuments.Although HTML allows a user to read documents in a dynamic manner, HTML is not, andnever has been, a programming language. While it is certainly true that, to the extent thatHTML helped propel the popularity of the Web, HTML was a catalyst for the creation ofJava, it did not directly influence the design of the language or the concepts behind it. Theonly connection that HTML has to Java is that it provides the applet tag, which executes aJava applet. Thus, it is possible to embed instructions in a hypertext document that cause aJava applet to execute.Chapter 2: An Overview of JavaOverviewLike all other computer languages, the elements of Java do not exist in isolation. Rather,they work together to form the language as a whole. However, this interrelatedness canmake it difficult to describe one aspect of Java without involving several others. Often adiscussion of one feature implies prior knowledge of another. For this reason, this chapterpresents a quick overview of several key features of Java. The material described here willgive you a foothold that will allow you to write and understand simple programs. Most of thetopics discussed will be examined in greater detail in the remaining chapters of Part 1.Object-Oriented ProgrammingObject-oriented programming is at the core of Java. In fact, all Java programs are object-oriented—this isnt an option the way that it is in C++, for example. OOP is so integral toJava that you must understand its basic principles before you can write even simple Javaprograms. Therefore, this chapter begins with a discussion of the theoretical aspects ofOOP.Two ParadigmsAs you know, all computer programs consist of two elements: code and data.Furthermore, a program can be conceptually organized around its code or around itsdata. That is, some programs are written around "what is happening" and others arewritten around "who is being affected." These are the two paradigms that govern how aprogram is constructed. The first way is called the process-oriented model. This approachcharacterizes a program as a series of linear steps (that is, code). The process-orientedmodel can be thought of as code acting on data. Procedural languages such as C employthis model to considerable success. However, as mentioned in Chapter 1, problems withthis approach appear as programs grow larger and more complex.To manage increasing complexity, the second approach, called object-orientedprogramming, was conceived. Object-oriented programming organizes a program aroundits data (that is, objects) and a set of well-defined interfaces to that data. An object-oriented program can be characterized as data controlling access to code. As you willsee, by switching the controlling entity to data, you can achieve several organizationalbenefits.AbstractionAn essential element of object-oriented programming is abstraction. Humans managecomplexity through abstraction. For example, people do not think of a car as a set of tensof thousands of individual parts. They think of it as a well-defined object with its ownunique behavior. This abstraction allows people to use a car to drive to the grocery storewithout being overwhelmed by the complexity of the parts that form the car. They canignore the details of how the engine, transmission, and braking systems work. Instead - 20 -
  21. 21. they are free to utilize the object as a whole.A powerful way to manage abstraction is through the use of hierarchical classifications.This allows you to layer the semantics of complex systems, breaking them into moremanageable pieces. From the outside, the car is a single object. Once inside, you seethat the car consists of several subsystems: steering, brakes, sound system, seat belts,heating, cellular phone, and so on. In turn, each of these subsystems is made up of morespecialized units. For instance, the sound system consists of a radio, a CD player, and/ora tape player. The point is that you manage the complexity of the car (or any othercomplex system) through the use of hierarchical abstractions.Hierarchical abstractions of complex systems can also be applied to computer programs.The data from a traditional process-oriented program can be transformed by abstractioninto its component objects. A sequence of process steps can become a collection ofmessages between these objects. Thus, each of these objects describes its own uniquebehavior. You can treat these objects as concrete entities that respond to messagestelling them to do something. This is the essence of object-oriented programming.Object-oriented concepts form the heart of Java just as they form the basis for humanunderstanding. It is important that you understand how these concepts translate intoprograms. As you will see, object-oriented programming is a powerful and naturalparadigm for creating programs that survive the inevitable changes accompanying the lifecycle of any major software project, including conception, growth, and aging. Forexample, once you have well-defined objects and clean, reliable interfaces to thoseobjects, you can gracefully decommission or replace parts of an older system withoutfear.The Three OOP PrinciplesAll object-oriented programming languages provide mechanisms that help you implementthe object-oriented model. They are encapsulation, inheritance, and polymorphism. Letstake a look at these concepts now.EncapsulationEncapsulation is the mechanism that binds together code and the data it manipulates,and keeps both safe from outside interference and misuse. One way to think aboutencapsulation is as a protective wrapper that prevents the code and data from beingarbitrarily accessed by other code defined outside the wrapper. Access to the code anddata inside the wrapper is tightly controlled through a well-defined interface. To relate thisto the real world, consider the automatic transmission on an automobile. It encapsulateshundreds of bits of information about your engine, such as how much you areaccelerating, the pitch of the surface you are on, and the position of the shift lever. You,as the user, have only one method of affecting this complex encapsulation: by moving thegear-shift lever. You cant affect the transmission by using the turn signal or windshieldwipers, for example. Thus, the gear-shift lever is a well-defined (indeed, unique) interfaceto the transmission. Further, what occurs inside the transmission does not affect objectsoutside the transmission. For example, shifting gears does not turn on the headlights!Because an automatic transmission is encapsulated, dozens of car manufacturers canimplement one in any way they please. However, from the drivers point of view, they allwork the same. This same idea can be applied to programming. The power ofencapsulated code is that everyone knows how to access it and thus can use itregardless of the implementation details—and without fear of unexpected side effects.In Java the basis of encapsulation is the class. Although the class will be examined ingreat detail later in this book, the following brief discussion will be helpful now. A classdefines the structure and behavior (data and code) that will be shared by a set of objects.Each object of a given class contains the structure and behavior defined by the class, asif it were stamped out by a mold in the shape of the class. For this reason, objects aresometimes referred to as instances of a class. Thus, a class is a logical construct; anobject has physical reality. - 21 -
  22. 22. When you create a class, you will specify the code and data that constitute that class.Collectively, these elements are called members of the class. Specifically, the datadefined by the class are referred to as member variables or instance variables. The codethat operates on that data is referred to as member methods or just methods. (If you arefamiliar with C/C++, it may help to know that what a Java programmer calls a method, aC/C++ programmer calls a function.) In properly written Java programs, the methodsdefine how the member variables can be used. This means that the behavior andinterface of a class are defined by the methods that operate on its instance data.Since the purpose of a class is to encapsulate complexity, there are mechanisms forhiding the complexity of the implementation inside the class. Each method or variable in aclass may be marked private or public. The public interface of a class representseverything that external users of the class need to know, or may know. The privatemethods and data can only be accessed by code that is a member of the class.Therefore, any other code that is not a member of the class cannot access a privatemethod or variable. Since the private members of a class may only be accessed by otherparts of your program through the class public methods, you can ensure that noimproper actions take place. Of course, this means that the public interface should becarefully designed not to expose too much of the inner workings of a class (see Figure 2-1). Figure 2.1: Encapsulation: public methods can be used to protect private dataInheritanceInheritance is the process by which one object acquires the properties of another object.This is important because it supports the concept of hierarchical classification. Asmentioned earlier, most knowledge is made manageable by hierarchical (that is, top-down) classifications. For example, a Golden Retriever is part of the classification dog,which in turn is part of the mammal class, which is under the larger class animal. Withoutthe use of hierarchies, each object would need to define all of its characteristics explicitly.However, by use of inheritance, an object need only define those qualities that make itunique within its class. It can inherit its general attributes from its parent. Thus, it is theinheritance mechanism that makes it possible for one object to be a specific instance of amore general case. Lets take a closer look at this process.Most people naturally view the world as made up of objects that are related to each otherin a hierarchical way, such as animals, mammals, and dogs. If you wanted to describeanimals in an abstract way, you would say they have some attributes, such as size,intelligence, and type of skeletal system. Animals also have certain behavioral aspects;they eat, breathe, and sleep. This description of attributes and behavior is the classdefinition for animals. - 22 -
  23. 23. If you wanted to describe a more specific class of animals, such as mammals, they wouldhave more specific attributes, such as type of teeth, and mammary glands. This is knownas a subclass of animals, where animals are referred to as mammals superclass.Since mammals are simply more precisely specified animals, they inherit all of theattributes from animals. A deeply inherited subclass inherits all of the attributes from eachof its ancestors in the class hierarchy.Inheritance interacts with encapsulation as well. If a given class encapsulates someattributes, then any subclass will have the same attributes plus any that it adds as part ofits specialization (see Figure 2-2). This is a key concept which lets object-orientedprograms grow in complexity linearly rather than geometrically. A new subclass inheritsall of the attributes of all of its ancestors. It does not have unpredictable interactions withthe majority of the rest of the code in the system. Figure 2.2: Labrador inherits the encapsulation of all of its superclasses - 23 -
  24. 24. PolymorphismPolymorphism (from the Greek, meaning "many forms") is a feature that allows oneinterface to be used for a general class of actions. The specific action is determined bythe exact nature of the situation. Consider a stack (which is a last-in, first-out list). Youmight have a program that requires three types of stacks. One stack is used for integervalues, one for floating-point values, and one for characters. The algorithm thatimplements each stack is the same, even though the data being stored differs. In a non–object-oriented language, you would be required to create three different sets of stackroutines, with each set using different names. However, because of polymorphism, inJava you can specify a general set of stack routines that all share the same names.More generally, the concept of polymorphism is often expressed by the phrase "oneinterface, multiple methods." This means that it is possible to design a generic interfaceto a group of related activities. This helps reduce complexity by allowing the sameinterface to be used to specify a general class of action. It is the compilers job to selectthe specific action (that is, method) as it applies to each situation. You, the programmer,do not need to make this selection manually. You need only remember and utilize thegeneral interface.Extending the dog analogy, a dogs sense of smell is polymorphic. If the dog smells a cat,it will bark and run after it. If the dog smells its food, it will salivate and run to its bowl. Thesame sense of smell is at work in both situations. The difference is what is being smelled,that is, the type of data being operated upon by the dogs nose! This same generalconcept can be implemented in Java as it applies to methods within a Java program.Polymorphism, Encapsulation, and Inheritance Work TogetherWhen properly applied, polymorphism, encapsulation, and inheritance combine toproduce a programming environment that supports the development of far more robustand scaleable programs than does the process-oriented model. A well-designedhierarchy of classes is the basis for reusing the code in which you have invested time andeffort developing and testing. Encapsulation allows you to migrate your implementationsover time without breaking the code that depends on the public interface of your classes.Polymorphism allows you to create clean, sensible, readable, and resilient code.Of the two real-world examples, the automobile more completely illustrates the power ofobject-oriented design. Dogs are fun to think about from an inheritance standpoint, butcars are more like programs. All drivers rely on inheritance to drive different types(subclasses) of vehicles. Whether the vehicle is a school bus, a Mercedes sedan, aPorsche, or the family minivan, drivers can all more or less find and operate the steeringwheel, the brakes, and the accelerator. After a bit of gear grinding, most people can evenmanage the difference between a stick shift and an automatic, because theyfundamentally understand their common superclass, the transmission.People interface with encapsulated features on cars all the time. The brake and gaspedals hide an incredible array of complexity with an interface so simple you can operatethem with your feet! The implementation of the engine, the style of brakes, and the size ofthe tires have no effect on how you interface with the class definition of the pedals.The final attribute, polymorphism, is clearly reflected in the ability of car manufacturers tooffer a wide array of options on basically the same vehicle. For example, you can get anantilock braking system or traditional brakes, power or rack-and-pinion steering, 4-, 6-, or8-cylinder engines. Either way, you will still press the break pedal to stop, turn thesteering wheel to change direction, and press the accelerator when you want to move.The same interface can be used to control a number of different implementations.As you can see, it is through the application of encapsulation, inheritance, andpolymorphism that the individual parts are transformed into the object known as a car. - 24 -
  25. 25. The same is also true of computer programs. By the application of object-oriented principles, the various parts of a complex program can be brought together to form a cohesive, robust, maintainable whole. As mentioned at the start of this section, every Java program is object-oriented. Or, put more precisely, every Java program involves encapsulation, inheritance, and polymorphism. Although the short example programs shown in the rest of this chapter and in the next few chapters may not seem to exhibit all of these features, they are nevertheless present. As you will see, many of the features supplied by Java are part of its built-in class libraries, which do make extensive use of encapsulation, inheritance, and polymorphism.A First Simple Program Now that the basic object-oriented underpinning of Java has been discussed, lets look at some actual Java programs. Lets start by compiling and running the short sample program shown here. As you will see, this involves a little more work than you might imagine. /* This is a simple Java program. Call this file "Example.java". */ class Example { // Your program begins with a call to main(). public static void main(String args[]) { System.out.println("This is a simple Java program."); } } Note The descriptions that follow use the standard JDK (Java Developers Kit), which is available from Sun Microsystems. If you are using a different Java development environment, then you may need to follow a different procedure for compiling and executing Java programs. In this case, consult your compilers user manuals for details. Entering the Program For most computer languages, the name of the file that holds the source code to a program is arbitrary. However, this is not the case with Java. The first thing that you must learn about Java is that the name you give to a source file is very important. For this example, the name of the source file should be Example.java. Lets see why. In Java, a source file is officially called a compilation unit. It is a text file that contains one or more class definitions. The Java compiler requires that a source file use the .java filename extension. Notice that the file extension is four characters long. As you might guess, your operating system must be capable of supporting long filenames. This means that DOS and Windows 3.1 are not capable of supporting Java (at least at this time). However, Windows 95/98 and Windows NT work just fine. As you can see by looking at the program, the name of the class defined by the program is also Example. This is not a coincidence. In Java, all code must reside inside a class. By convention, the name of that class should match the name of the file that holds the program. You should also make sure that the capitalization of the filename matches the class name. The reason for this is that Java is case-sensitive. At this point, the convention that filenames correspond to class names may seem arbitrary. However, this convention makes it easier to maintain and organize your programs. Compiling the Program - 25 -
  26. 26. To compile the Example program, execute the compiler, javac, specifying the name ofthe source file on the command line, as shown here:C:>javac Example.javaThe javac compiler creates a file called Example.class that contains the bytecodeversion of the program. As discussed earlier, the Java bytecode is the intermediaterepresentation of your program that contains instructions the Java interpreter willexecute. Thus, the output of javac is not code that can be directly executed.To actually run the program, you must use the Java interpreter, called java. To do so,pass the class name Example as a command-line argument, as shown here:C:>java ExampleWhen the program is run, the following output is displayed:This is a simple Java program.When Java source code is compiled, each individual class is put into its own output filenamed after the class and using the .class extension. This is why it is a good idea to giveyour Java source files the same name as the class they contain—the name of the sourcefile will match the name of the .class file. When you execute the Java interpreter as justshown, you are actually specifying the name of the class that you want the interpreter toexecute. It will automatically search for a file by that name that has the .class extension.If it finds the file, it will execute the code contained in the specified class.A Closer Look at the First Sample ProgramAlthough Example.java is quite short, it includes several key features which are commonto all Java programs. Lets closely examine each part of the program.The program begins with the following lines:/* This is a simple Java program. Call this file "Example.java".*/This is a comment. Like most other programming languages, Java lets you enter aremark into a programs source file. The contents of a comment are ignored by thecompiler. Instead, a comment describes or explains the operation of the program toanyone who is reading its source code. In this case, the comment describes the programand reminds you that the source file should be called Example.java. Of course, in realapplications, comments generally explain how some part of the program works or what aspecific feature does.Java supports three styles of comments. The one shown at the top of the program iscalled a multiline comment. This type of comment must begin with /* and end with */.Anything between these two comment symbols is ignored by the compiler. As the namesuggests, a multiline comment may be several lines long.The next line of code in the program is shown here:class Example {This line uses the keyword class to declare that a new class is being defined. Exampleis an identifier that is the name of the class. The entire class definition, including all of its - 26 -
  27. 27. members, will be between the opening curly brace ({) and the closing curly brace (}). Theuse of the curly braces in Java is identical to the way they are used in C and C++. For themoment, dont worry too much about the details of a class except to note that in Java, allprogram activity occurs within one. This is one reason why all Java programs are (at leasta little bit) object-oriented.The next line in the program is the single-line comment, shown here:// Your program begins with a call to main().This is the second type of comment supported by Java. A single-line comment beginswith a // and ends at the end of the line. As a general rule, programmers use multilinecomments for longer remarks and single-line comments for brief, line-by-line descriptions.The next line of code is shown here:public static void main(String args[]) {This line begins the main( ) method. As the comment preceding it suggests, this is theline at which the program will begin executing. All Java applications begin execution bycalling main( ). (This is just like C/C++.) The exact meaning of each part of this linecannot be given now, since it involves a detailed understanding of Javas approach toencapsulation. However, since most of the examples in the first part of this book will usethis line of code, lets take a brief look at each part now.The public keyword is an access specifier, which allows the programmer to control thevisibility of class members. When a class member is preceded by public, then thatmember may be accessed by code outside the class in which it is declared. (Theopposite of public is private, which prevents a member from being used by code definedoutside of its class.) In this case, main( ) must be declared as public, since it must becalled by code outside of its class when the program is started. The keyword staticallows main( ) to be called without having to instantiate a particular instance of the class.This is necessary since main( ) is called by the Java interpreter before any objects aremade. The keyword void simply tells the compiler that main( ) does not return a value.As you will see, methods may also return values. If all this seems a bit confusing, dontworry. All of these concepts will be discussed in detail in subsequent chapters.As stated, main( ) is the method called when a Java application begins. Keep in mindthat Java is case-sensitive. Thus, Main is different from main. It is important tounderstand that the Java compiler will compile classes that do not contain a main( )method. But the Java interpreter has no way to run these classes. So, if you had typedMain instead of main, the compiler would still compile your program. However, the Javainterpreter would report an error because it would be unable to find the main( ) method.Any information that you need to pass to a method is received by variables specifiedwithin the set of parentheses that follow the name of the method. These variables arecalled parameters. If there are no parameters required for a given method, you still needto include the empty parentheses. In main( ), there is only one parameter, albeit acomplicated one. String args[ ] declares a parameter named args, which is an array ofinstances of the class String. (Arrays are collections of similar objects.) Objects of typeString store character strings. In this case, args receives any command-line argumentspresent when the program is executed. This program does not make use of thisinformation, but other programs shown later in this book will.The last character on the line is the {. This signals the start of main( )s body. All of thecode that comprises a method will occur between the methods opening curly brace andits closing curly brace.One other point: main( ) is simply a starting place for the interpreter. A complex programwill have dozens of classes, only one of which will need to have a main( ) method to get - 27 -
  28. 28. things started. When you begin creating applets—Java programs that are embedded inWeb browsers—you wont use main( ) at all, since the Web browser uses a differentmeans of starting the execution of applets.The next line of code is shown here. Notice that it occurs inside main( ).System.out.println("This is a simple Java program.");This line outputs the string "This is a simple Java program." followed by a new line on thescreen. Output is actually accomplished by the built-in println( ) method. In this case,println( ) displays the string which is passed to it. As you will see, println( ) can be usedto display other types of information, too. The line begins with System.out. While toocomplicated to explain in detail at this time, briefly, System is a predefined class thatprovides access to the system, and out is the output stream that is connected to theconsole.As you have probably guessed, console output (and input) is not used frequently in realJava programs and applets. Since most modern computing environments are windowedand graphical in nature, console I/O is used mostly for simple, utility programs and fordemonstration programs. Later in this book, you will learn other ways to generate outputusing Java. But for now, we will continue to use the console I/O methods.Notice that the println( ) statement ends with a semicolon. All statements in Java endwith a semicolon. The reason that the other lines in the program do not end in asemicolon is that they are not, technically, statements.The first } in the program ends main( ), and the last } ends the Example class definition.A Second Short ProgramPerhaps no other concept is more fundamental to a programming language than that of avariable. As you probably know, a variable is a named memory location that may beassigned a value by your program. The value of a variable may be changed during theexecution of the program. The next program shows how a variable is declared and how itis assigned a value. In addition, the program also illustrates some new aspects ofconsole output. As the comments at the top of the program state, you should call this fileExample2.java./* Here is another short example. Call this file "Example2.java".*/class Example2 { public static void main(String args[]) { int num; // this declares a variable called num num = 100; // this assigns num the value 100 System.out.println("This is num: " + num); num = num * 2; System.out.print("The value of num * 2 is "); System.out.println(num); }}When you run this program, you will see the following output: - 28 -
  29. 29. This is num: 100 The value of num * 2 is 200 Lets take a close look at why this output is generated. The first new line in the program is shown here: int num; // this declares a variable called num This line declares an integer variable called num. Java (like most other languages) requires that variables be declared before they are used. Following is the general form of a variable declaration: type var-name; Here, type specifies the type of variable being declared, and var-name is the name of the variable. If you want to declare more than one variable of the specified type, you may use a comma-separated list of variable names. Java defines several data types, including integer, character, and floating-point. The keyword int specifies an integer type. In the program, the line num = 100; // this assigns num the value 100 assigns to num the value 100. In Java, the assignment operator is a single equal sign. The next line of code outputs the value of num preceded by the string "This is num:". System.out.println("This is num: " + num); In this statement, the plus sign causes the value of num to be appended to the string that precedes it, and then the resulting string is output. (Actually, num is first converted from an integer into its string equivalent and then concatenated with the string that precedes it. This process is described in detail later in this book.) This approach can be generalized. Using the + operator, you can string together as many items as you want within a single println( ) statement. The next line of code assigns num the value of num times 2. Like most other languages, Java uses the * operator to indicate multiplication. After this line executes, num will contain the value 200. Here are the next two lines in the program: System.out.print("The value of num * 2 is "); System.out.println(num); Several new things are occurring here. First, the built-in method print( ) is used to display the string "The value of num * 2 is ". This string is not followed by a newline. This means that when the next output is generated, it will start on the same line. The print( ) method is just like println( ), except that it does not output a newline character after each call. Now look at the call to println( ). Notice that num is used by itself. Both print( ) and println( ) can be used to output values of any of Javas built-in types.Two Control Statements Although Chapter 5 will look closely at control statements, two are briefly introduced here so that they can be used in example programs in Chapters 3 and 4. They will also help - 29 -
  30. 30. illustrate an important aspect of Java: blocks of code.The if StatementThe Java if statement works much like the IF statement in any other language. Further, itis syntactically identical to the if statements in C and C++. Its simplest form is shownhere:if(condition) statement;Here, condition is a Boolean expression. If condition is true, then the statement isexecuted. If condition is false, then the statement is bypassed. Here is an example:if(num < 100) println("num is less than 100");In this case, if num contains a value that is less than 100, the conditional expression istrue, and println( ) will execute. If num contains a value greater than or equal to 100,then the println( ) method is bypassed.As you will see in Chapter 4, Java defines a full complement of relational operators whichmay be used in a conditional expression. Here are a few:Operator Meaning< Less than> Greater than== Equal toNotice that the test for equality is the double equal sign.Here is a program that illustrates the if statement:/* Demonstrate the if. Call this file "IfSample.java".*/class IfSample { public static void main(String args[]) { int x, y; x = 10; y = 20; if(x < y) System.out.println("x is less than y"); x = x * 2; if(x == y) System.out.println("x now equal to y"); x = x * 2; if(x > y) System.out.println("x now greater than y"); // this wont display anything if(x == y) System.out.println("you wont see this"); }} - 30 -
  31. 31. The output generated by this program is shown here:x is less than yx now equal to yx now greater than yNotice one other thing in this program. The lineint x, y;declares two variables, x and y, by use of a comma-separated list.The for LoopAs you may know from your previous programming experience, loop statements are animportant part of nearly any programming language. Java is no exception. In fact, as youwill see in Chapter 5, Java supplies a powerful assortment of loop constructs. Perhapsthe most versatile is the for loop. If you are familiar with C or C++, then you will bepleased to know that the for loop in Java works the same way it does in those languages.If you dont know C/C++, the for loop is still easy to use. The simplest form of the for loopis shown here:for(initialization; condition; iteration) statement;In its most common form, the initialization portion of the loop sets a loop control variableto an initial value. The condition is a Boolean expression that tests the loop controlvariable. If the outcome of that test is true, the for loop continues to iterate. If it is false,the loop terminates. The iteration expression determines how the loop control variable ischanged each time the loop iterates. Here is a short program that illustrates the for loop:/* Demonstrate the for loop. Call this file "ForTest.java".*/class ForTest { public static void main(String args[]) { int x; for(x = 0; x<10; x = x+1) System.out.println("This is x: " + x); }}This program generates the following output:This is x: 0This is x: 1This is x: 2This is x: 3This is x: 4This is x: 5This is x: 6This is x: 7This is x: 8This is x: 9 - 31 -
  32. 32. In this example, x is the loop control variable. It is initialized to zero in the initialization portion of the for. At the start of each iteration (including the first one), the conditional test x < 10 is performed. If the outcome of this test is true, the println( ) statement is executed, and then the iteration portion of the loop is executed. This process continues until the conditional test is false. As a point of interest, in professionally written Java programs you will almost never see the iteration portion of the loop written as shown in the preceding program. That is, you will seldom see statements like this: x = x + 1; The reason is that Java includes a special increment operator which performs this operation more efficiently. The increment operator is ++. (That is, two plus signs back to back.) The increment operator increases its operand by one. By use of the increment operator, the preceding statement can be written like this: x++; Thus, the for in the preceding program will usually be written like this: for(x = 0; x<10; x++) You might want to try this. As you will see, the loop still runs exactly the same as it did before. Java also provides a decrement operator, which is specified as – –. This operator decreases its operand by one.Using Blocks of Code Java allows two or more statements to be grouped into blocks of code, also called code blocks. This is done by enclosing the statements between opening and closing curly braces. Once a block of code has been created, it becomes a logical unit that can be used any place that a single statement can. For example, a block can be a target for Javas if and for statements. Consider this if statement: if(x < y) { // begin a block x = y; y = 0; } // end of block Here, if x is less than y, then both statements inside the block will be executed. Thus, the two statements inside the block form a logical unit, and one statement cannot execute without the other also executing. The key point here is that whenever you need to logically link two or more statements, you do so by creating a block. Lets look at another example. The following program uses a block of code as the target of a for loop. /* Demonstrate a block of code. Call this file "BlockTest.java" */ class BlockTest { public static void main(String args[]) { int x, y; - 32 -
  33. 33. y = 20; // the target of this loop is a block for(x = 0; x<10; x++) { System.out.println("This is x: " + x); System.out.println("This is y: " + y); y = y - 2; } }}The output generated by this program is shown here:This is x: 0This is y: 20This is x: 1This is y: 18This is x: 2This is y: 16This is x: 3This is y: 14This is x: 4This is y: 12This is x: 5This is y: 10This is x: 6This is y: 8This is x: 7This is y: 6This is x: 8This is y: 4This is x: 9This is y: 2In this case, the target of the for loop is a block of code and not just a single statement.Thus, each time the loop iterates, the three statements inside the block will be executed.This fact is, of course, evidenced by the output generated by the program.As you will see later in this book, blocks of code have additional properties and uses.However, the main reason for their existence is to create logically inseparable units ofcode.Lexical IssuesNow that you have seen several short Java programs, it is time to more formally describethe atomic elements of Java. Java programs are a collection of whitespace, identifiers,comments, literals, operators, separators, and keywords. The operators are described inthe next chapter. The others are described next.WhitespaceJava is a free-form language. This means that you do not need to follow any specialindentation rules. For example, the Example program could have been written all on oneline or in any other strange way you felt like typing it, as long as there was at least onewhitespace character between each token that was not already delineated by an operatoror separator. In Java, whitespace is a space, tab, or newline.Identifiers - 33 -

×