Additional Imaging Classes. Using Synchronization Objects. Using an Executor. A Simple Executor Example. Using Callable and Future. The TimeUnit Enumeration. The Concurrent Collections. Atomic Operations. NIO Fundamentals. Charsets and Selectors.
Using the NIO System. Regular Expression Processing. Regular Expression Syntax. Demonstrating Pattern Matching. Exploring Regular Expressions. Text Formatting. DateFormat Class.
SimpleDateFormat Class. What Is a Java Bean? Advantages of Java Beans. Design Patterns for Properties. Design Patterns for Events. Methods and Design Patterns. Using the BeanInfo Interface. Bound and Constrained Properties. A Bean Example. The Origins of Swing. Two Key Swing Features. Swing Components Are Lightweight. Swing Supports a Pluggable Look and Feel. The MVC Connection. Components and Containers. The Top-Level Container Panes.
The Swing Packages. A Simple Swing Application. Create a Swing Applet. Painting in Swing. Compute the Paintable Area. A Paint Example. JLabel and ImageIcon. The Swing Buttons. Check Boxes.
Radio Buttons. Continuing Your Exploration of Swing. The Life Cycle of a Servlet. Using Tomcat for Servlet Development. A Simple Servlet. Create and Compile the Servlet Source Code. Start Tomcat. Start a Web Browser and Request the Servlet. The Servlet API. The javax. The Servlet Interface. The ServletConfig Interface. The ServletContext Interface. The ServletRequest Interface.
The ServletResponse Interface. The GenericServlet Class. The ServletInputStream Class. The ServletOutputStream Class. The Servlet Exception Classes. Reading Servlet Parameters. The HttpServletRequest Interface. The HttpServletResponse Interface. The HttpSession Interface. The Cookie Class. The HttpSessionEvent Class. Using Cookies. Session Tracking. Finding the Payments for a Loan. The RegPay Fields. The init Method.
The makeGUI Method. The actionPerformed Method. The compute Method. Finding the Future Value of an Investment. Finding the Maximum Annuity for a Given Investment. Finding the Remaining Balance on a Loan. Creating Financial Servlets. Converting the RegPay Applet into a Servlet. The RegPayS Servlet. Some Things to Try. Understanding Internet Downloads.
An Overview of the Download Manager. The Download Class. The Download Variables. The Download Constructor. The download Method. The run Method. The stateChanged Method. Action and Accessor Methods. The ProgressRenderer Class. The DownloadsTableModel Class. The addDownload Method. The clearDownload Method. The getColumnClass Method. The getValueAt Method. The update Method. The DownloadManager Variables. The DownloadManager Constructor. The verifyUrl Method.
The tableSelectionChanged Method. The updateButtons Method. Handling Action Events. Compiling and Running the Download Manager. Enhancing the Download Manager. The javadoc Tags. The General Form of a Documentation Comment. What javadoc Outputs. An Example that Uses Documentation Comments.
Java leapt to the forefront of Internet programming with its first release. Each subsequent version has solidified that position. Today, Java is still the first and best choice for developing web-based applications. Java has rapidly adapted to changes in the programming environment and to changes in the way that programmers program.
Most importantly, it has not just followed the trends, it has helped create them. If you are programming for the Internet, you have chosen the right language. Java has been and continues to be the preeminent language of the Internet. As many readers will know, this is the seventh edition of the book, which was first published in This edition has been updated for Java SE 6.
It has also been expanded in several key areas. Here are two examples: it now includes twice as much coverage of Swing and a more detailed discussion of resource bundles. Throughout are many other additions and improvements. In all, dozens of pages of new material have been incorporated.
A Book for All Programmers This book is for all programmers, whether you are a novice or an experienced pro. The beginner will find its carefully paced discussions and many examples especially helpful.
For both, it offers a lasting resource and handy reference. Significant portions of the Java API library are also examined. The book is divided into four parts, each focusing on a different aspect of the Java programming environment. It begins with the basics, including such things as data types, control statements, and classes. Part IV contains two chapters that show examples of Java in action.
The first chapter develops several applets that perform various popular financial calculations, such as computing the regular payment on a loan or the minimum investment needed to withdraw a desired monthly annuity. This chapter also shows how to convert those applets into servlets.
The second chapter develops a download manager that oversees the downloading of files. It includes the ability to start, stop, and resume a transfer. Special Thanks Special thanks to Patrick Naughton. Patrick was one of the creators of the Java language. He also helped write the first edition of this book. For example, much of the material in Chapters 19, 20, and 25 was initially provided by Patrick. His insights, expertise, and energy contributed greatly to the success of this book.
Joe has helped on several of my books and, as always, his efforts are appreciated. Finally, many thanks to James Holmes for providing Chapter James is an extraordinary programmer and author.
Here are some others that you will find of interest. 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 mission. While the remaining chapters of this book describe the practical aspects of Java—including its syntax, key libraries, and applications—this chapter explains how and why Java came about, what makes it so important, and how it has evolved over the years.
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. Much of the character of Java is inherited from these two languages. From C, Java derives its syntax. 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 several decades. For these reasons, this section reviews the sequence of events and forces that led 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. 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. For example, although FORTRAN could be used to write fairly efficient programs for scientific applications, it was not very good for system code. Assembly language can be used to produce highly efficient programs, but it is not easy to learn or use effectively.
Further, debugging assembly code can be quite difficult. Instead, they relied upon the GOTO as a primary means of program control. While languages like Pascal are structured, they were not designed for efficiency, and failed to include certain features necessary to make them applicable to a wide range of programs.
Specifically, given the standard dialects of Pascal available at the time, it was not practical to consider using Pascal for systems-level code. So, just prior to the invention of C, no one language had reconciled the conflicting attributes that had dogged earlier efforts. Yet the need for such a language was pressing. A great deal of effort was being expended in academic circles in an attempt to create a better computer language.
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 being reached. No longer were computers kept behind locked doors. For the first time, programmers were gaining virtually unlimited access to their machines. This allowed the freedom to experiment.
It also allowed programmers to begin to create their own tools. Chapter 1: The History and Evolution of Java The creation of C is considered by many to have marked the beginning of the modern age of computer languages. It successfully synthesized the conflicting attributes that had so troubled earlier languages. The result was a powerful, efficient, structured language that was relatively easy to learn. Prior to the invention of C, computer languages were generally designed either as academic exercises or by bureaucratic committees.
C is different. 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. The result was a language that programmers liked to use.
Indeed, C quickly attracted many followers who had a near-religious zeal for it. As such, it found wide and rapid acceptance in the programmer community. In short, C is a language designed by and for programmers. As you will see, Java inherited this legacy. 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 driven the need for better ways to manage that complexity. Approaches to programming have changed dramatically since the invention of the computer.
For example, when computers were first invented, programming was done by manually toggling in the binary machine instructions by use of the front panel. As long as programs were just a few hundred instructions long, this approach worked. As programs grew, assembly language was invented so that a programmer could deal with larger, increasingly complex programs by using symbolic representations of the machine instructions.
As programs continued to grow, high-level languages were introduced that gave the programmer more tools with which to handle complexity. The s gave birth to structured programming. This is the method of programming championed by languages such as C. The use of structured languages enabled programmers to write, for the first time, moderately complex programs fairly easily. However, even with structured programming methods, once a project reaches a certain size, its complexity exceeds what a programmer can manage.
By the early s, many projects were pushing the structured approach past its limits. To solve this problem, a new way to program was invented, called object-oriented programming OOP.
Object-oriented programming is discussed in detail later in this book, but here is a brief definition: OOP is a programming methodology that helps organize complex programs through the use of inheritance, encapsulation, and polymorphism. Once the size of a program exceeds a certain point, it becomes so complex that it is difficult to grasp as a totality. While the precise size at which this occurs differs, depending upon both the nature of the program and the programmer, there is always a threshold at which a program becomes unmanageable.
Instead, it was an enhancement to an already highly successful one. Indeed, for a brief moment it seemed as if programmers had finally found the perfect language. However, just as in the past, forces were brewing that would, once again, drive computer language evolution forward. Within a few years, the World Wide Web and the Internet would reach critical mass. This event would precipitate another revolution in programming.
It took 18 months to develop the first working version. Between the initial implementation of Oak in the fall of and the public announcement of Java in the spring of , many more people contributed to the design and evolution of the language.
Somewhat surprisingly, the original impetus for Java was not the Internet! Instead, the primary 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 consumer electronic devices, such as microwave ovens and remote controls. As you can probably guess, many different types of CPUs are used as controllers.
The problem is that compilers are expensive and time-consuming to create. An easier—and more cost-efficient—solution was needed. In an attempt to find such a solution, Gosling and others began work on a portable, platform-independent language that could be used to produce code that would run on a variety of CPUs under differing environments. This effort ultimately led to the creation of Java. About the time that the details of Java were being worked out, a second, and ultimately more 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 at about the same time that Java was being implemented, Java might have remained a useful but obscure language for programming consumer electronics. However, with the emergence of the World Wide Web, Java was propelled to the forefront of computer language design, because the Web, too, demanded portable programs.
Chapter 1: The History and Evolution of Java Most programmers learn early in their careers that portable programs are as elusive as they 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 had taken a back seat to other, more pressing problems.
Further, because at that time much of the computer world had divided itself into the three competing camps of Intel, Macintosh, and UNIX, most programmers stayed within their fortified boundaries, and the urgent need for portable code was reduced. However, with the advent of the Internet and the Web, the old problem of portability returned with a vengeance. After all, the Internet consists of a diverse, distributed universe populated with various types of computers, operating systems, and CPUs.
Even though many kinds of platforms are attached to the Internet, users would like them all to be able to run the same program. What was once an irritating but low-priority problem had become a high-profile necessity. By , it became obvious to members of the Java design team that the problems of portability frequently encountered when creating code for embedded controllers are also found when attempting to create code for the Internet.
In fact, the same problem that Java was initially designed to solve on a small scale could also be applied to the Internet on a large scale. This realization caused the focus of Java to switch from consumer electronics to Internet programming.
This is by intent. First, Java was designed, tested, and refined by real, working programmers. It is a language grounded in the needs and experiences of the people who devised it.
Second, Java is cohesive and logically consistent. Third, except for those constraints imposed by the Internet environment, Java gives you, the 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. Java has significant practical and philosophical differences.
Java was designed to solve a certain 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.
In the final analysis, though, it was not the individual features of Java that made it so remarkable. Java was the perfect response to the demands of the then newly emerging, highly distributed computing universe.
Java was to Internet programming what C was to system programming: a revolutionary force that changed the world. The C Connection The reach and power of Java continues to be felt in the world of computer language development.
Many of its innovative features, constructs, and concepts have become part of the baseline for any new language. The success of Java is simply too important to ignore. Created by Microsoft to support the. For example, both share the same general syntax, support distributed programming, and utilize the same object model.
How Java Changed the Internet The Internet helped catapult Java to the forefront of programming, and Java, in turn, had a profound effect on the Internet. In addition to simplifying web programming in general, Java innovated a new type of networked program called the applet that changed the way the online world thought about content. Java also addressed some of the thorniest issues associated with the Internet: portability and security. Java Applets An applet is a special kind of Java program that is designed to be transmitted over the Internet and automatically executed by a Java-compatible web browser.
Furthermore, an applet is downloaded on demand, without further interaction with the user. If the user clicks a link that contains an applet, the applet will be automatically downloaded and run in the browser.
Applets are intended to be small programs. They are typically used to display data provided by the server, handle user input, or provide simple functions, such as a loan calculator, that execute locally, rather than on the server.
In essence, the applet allows some functionality to be moved from the server to the client. The creation of the applet changed Internet programming because it expanded the universe of objects that can move about freely in cyberspace. In general, there are two very broad categories of objects that are transmitted between the server and the client: passive information and dynamic, active programs.
For example, when you read your e-mail, you are viewing passive data. By contrast, the applet is a dynamic, self-executing program. Such a program is an active agent on the client computer, yet it is initiated by the server. As desirable as dynamic, networked programs are, they also present serious problems in the areas of security and portability.
Obviously, a program that downloads and executes automatically on the client computer must be prevented from doing harm. It must also be able to run in a variety of different environments and under different operating systems. As you will see, Java solved these problems in an effective and elegant way.
At the core of the problem is the fact that malicious code can cause its damage because it has gained unauthorized access to system resources. In order for Java to enable applets to be downloaded and executed on the client computer safely, it was necessary to prevent an applet from launching such an attack.
Java achieved this protection by confining an applet 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 innovative aspect of Java.
Portability Portability is a major aspect of the Internet because there are many different types of computers and operating systems connected to it.
If a Java program were to be run on virtually any computer connected to the Internet, there needed to be some way to enable that program to execute on different systems. For example, in the case of an applet, the same applet must be able to be downloaded and executed by the wide variety of CPUs, operating systems, and browsers connected to the Internet.
It is not practical to have different versions of the applet for different computers. The same code must work on all computers. Therefore, some means of generating portable executable code was needed.
As you will soon see, the same mechanism that helps ensure security also helps create portability. 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.
In essence, the original JVM was designed as an interpreter for bytecode. This may come as a bit of a surprise since many modern languages are designed to be compiled into executable code because of performance concerns.
However, the fact that a Java program is executed by the JVM helps solve the major problems associated with web-based programs. Here is why. Translating a Java program into bytecode makes it much easier to run a program in a wide variety of environments because 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 understand 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 execution of bytecode by the JVM is the easiest way to create truly portable programs. The fact that a Java program is executed by the JVM also helps to make it secure. Because the JVM is in control, it can contain the program and prevent it from generating 9 10 Part I: The Java Language side effects outside of the system.
As you will see, safety is also enhanced by certain restrictions that exist in the Java language. In general, when a program is compiled to an intermediate form and then interpreted by a virtual machine, it runs slower than it would run if compiled to executable code. However, with Java, the differential between the two is not so great. Because bytecode has been highly optimized, the use of bytecode enables the JVM to execute programs much faster than you might expect.
Although Java was designed as an interpreted language, there is nothing about Java that prevents on-the-fly compilation of bytecode into native code in order to boost performance.
When a JIT compiler is part of the JVM, selected portions of bytecode are compiled into executable code in real time, on a piece-by-piece, demand basis. It is important to understand that it is not practical 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, a JIT compiler compiles code as it is needed, during execution. Furthermore, not all sequences of bytecode are compiled—only those that will benefit from compilation.
The remaining code is simply interpreted. 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 JVM is still in charge of the execution environment. Not long after the initial release of Java, it became obvious that Java would also be useful on the server side.
The result was the servlet. A servlet is a small program that executes on the server. Just as applets dynamically extend the functionality of a web browser, servlets dynamically extend the functionality of a web server.
Servlets are used to create dynamically generated content that is then served to the client. For example, an online store might use a servlet to look up the price for an item in a database.
The price information is then used to dynamically generate a web page that is sent to the browser. Although dynamically generated content is available through mechanisms such as CGI Common Gateway Interface , the servlet offers several advantages, including increased performance.
Because servlets like all Java programs are compiled into bytecode and executed by the JVM, they are highly portable. Thus, the same servlet can be used in a variety of different server environments. The only requirements are that the server support the JVM and a servlet container.
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. 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.
Object-Oriented Although influenced by its predecessors, Java was not designed to be source-code compatible with any other language. This allowed the Java team the freedom to design with a blank slate.
One outcome of this was a clean, usable, pragmatic approach to objects. The object model in Java is simple and easy to extend, while primitive types, such as integers, are kept as high-performance nonobjects. Robust The multiplatformed environment of the Web places extraordinary demands on a program, because the program must execute reliably in a variety of systems.
Thus, the ability to create robust programs was given a high priority in the design of Java. To gain reliability, Java restricts you in a few key areas to force you to find your mistakes early in program development.
At the same time, Java frees you from having to worry about many of the most common causes of programming errors. Because Java is a strictly typed language, it checks your code at compile time. However, it also checks your code at run time. Many hard-to-track-down bugs that often turn up in hard-to-reproduce run-time situations are simply impossible to create in Java.
Knowing that what you have written will behave in a predictable way under diverse conditions is a key feature of Java. Memory management can be a difficult, tedious task in traditional programming environments. This sometimes leads to problems, because programmers 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 virtually eliminates these problems by managing memory allocation and deallocation for you. In fact, deallocation is completely automatic, because Java provides garbage collection for unused objects. Java helps in this area by providing object-oriented exception handling. In a well-written Java program, all run-time errors can—and should—be managed by your program. Multithreaded Java was designed to meet the real-world requirement of creating interactive, networked programs.
To accomplish this, Java supports multithreaded programming, which allows you to write programs that do many things simultaneously. The Java run-time system comes with an elegant yet sophisticated solution for multiprocess synchronization that enables you to construct smoothly running interactive systems. Architecture-Neutral A central issue for the Java designers was that of code longevity and portability.
One of the main problems facing programmers is that no guarantee exists that if you write a program today, it will run tomorrow—even on the same machine. Operating system upgrades, processor upgrades, and changes in core system resources can all combine to make a program malfunction. The Java designers made several hard decisions in the Java language and the Java Virtual Machine in an attempt to alter this situation.
Interpreted and High Performance As described earlier, Java enables the creation of cross-platform programs by compiling into an intermediate representation called Java bytecode.
This code can be executed on any system that implements the Java Virtual Machine. Most previous attempts at cross-platform solutions have done so at the expense of performance. As explained earlier, the Java bytecode was carefully designed so that it would be easy to translate directly into native machine code for very high performance by using a just-in-time compiler.
Java run-time systems that provide this feature lose none of the benefits of the platform-independent code. In fact, accessing a resource using a URL is not much different from accessing a file.
This feature enables a program to invoke methods across a network. Chapter 1: The History and Evolution of Java Dynamic Java programs carry with them substantial amounts of run-time type information that is used to verify and resolve accesses to objects at run time.
This makes it possible to dynamically link code in a safe and expedient manner. This is crucial to the robustness of the Java environment, in which small fragments of bytecode may be dynamically updated on a running system.
Unlike most other software systems that usually settle into a pattern of small, incremental improvements, Java continued to evolve at an explosive pace. Soon after the release of Java 1. The features added by Java 1. Java 1. It also deprecated rendered obsolete several features originally defined by Java 1. Thus, Java 1. It may seem odd that the first release of Java 2 used the 1. The reason is that it originally referred to the internal version number of the Java libraries, but then was generalized to refer to the entire release.
Java 2 added support for a number of new features, such as Swing and the Collections Framework, and it enhanced the Java Virtual Machine and various programming tools. Java 2 also contained a few deprecations.
The most important affected the Thread class in which the methods suspend , resume , and stop were deprecated. J2SE 1. In general, programs written for version 1. Although version 1. The release of J2SE 1. This release contained several important upgrades, enhancements, and additions.
It also made changes to the Collections Framework and the networking classes. In addition, numerous small changes were made throughout. Despite the significant number of new features, version 1. The next release of Java was J2SE 5, and it was revolutionary. Unlike most of the previous Java upgrades, which offered important, but measured improvements, J2SE 5 fundamentally expanded the scope, power, and range of the language. Each item in the list represents a significant addition to the Java language.
Some, such as generics, the enhanced for, and varargs, introduce new syntax elements. Others, such as autoboxing and auto-unboxing, alter the semantics of the language. Annotations add an entirely new dimension to programming. In all cases, the impact of these additions went beyond their direct effects. They changed the very character of Java itself.
However, the new features were so significant that a shift from 1. Instead, Sun elected to increase the version number to 5 as a way of emphasizing that a major event was taking place. However, in order to maintain consistency, Sun decided to use 1.
The internal, developer version number is 1. Java SE 6 adds no major features to the Java language proper, but it does enhance the API libraries, add several new packages, and offer improvements to the run time. As it relates to this book, it is the changes to the core API that are the most notable.
Many of the packages have new classes, and many of the classes have new methods. These changes are indicated throughout the book. A Culture of Innovation Since the beginning, Java has been at the center of a culture of innovation. Its original release redefined programming for the Internet. The applet and then the servlet made the Web come alive. The world of Java has never stood still for very long. Rather, they work together to form the language as a whole. However, this interrelatedness can make it difficult to describe one aspect of Java without involving several others.
Often a discussion of one feature implies prior knowledge of another. For this reason, this chapter presents a quick overview of several key features of Java. The material described here will give you a foothold that will allow you to write and understand simple programs. Most of the topics discussed will be examined in greater detail in the remaining chapters of Part I.
In fact, all Java programs are to at least some extent object-oriented. OOP is so integral to Java that it is best to understand its basic principles before you begin writing even simple Java programs.
Therefore, this chapter begins with a discussion of the theoretical aspects of OOP. Two Paradigms All computer programs consist of two elements: code and data. Furthermore, a program can be conceptually organized around its code or around its data. The first way is called the process-oriented model. This approach characterizes a program as a series of linear steps that is, code. The process-oriented model can be thought of as code acting on data. Procedural languages such as C employ this model to considerable success.
However, as mentioned in Chapter 1, problems with this approach appear as programs grow larger and more complex. To manage increasing complexity, the second approach, called object-oriented programming, was conceived. Object-oriented programming organizes a program around its 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 will see, by switching the controlling entity to data, you can achieve several organizational benefits.
Humans manage complexity through abstraction. For example, people do not think of a car as a set of tens of thousands of individual parts. They think of it as a well-defined object with its own unique behavior. This abstraction allows people to use a car to drive to the grocery store without being overwhelmed by the complexity of the parts that form the car.
They can ignore the details of how the engine, transmission, and braking systems work. Instead, 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 more manageable pieces. From the outside, the car is a single object. Once inside, you see that 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 more specialized units.
The point is that you manage the complexity of the car or any other complex 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 abstraction into its component objects. A sequence of process steps can become a collection of messages between these objects. Thus, each of these objects describes its own unique behavior. You can treat these objects as concrete entities that respond to messages telling 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 human understanding.
It is important that you understand how these concepts translate into programs. As you will see, object-oriented programming is a powerful and natural paradigm for creating programs that survive the inevitable changes accompanying the life cycle of any major software project, including conception, growth, and aging. For example, once you have well-defined objects and clean, reliable interfaces to those objects, you can gracefully decommission or replace parts of an older system without fear.
The Three OOP Principles All object-oriented programming languages provide mechanisms that help you implement the object-oriented model. They are encapsulation, inheritance, and polymorphism. Encapsulation Encapsulation 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 about encapsulation is as a protective wrapper that prevents the code and data from being arbitrarily accessed by other code defined outside the wrapper.
Access to the code and data inside the wrapper is tightly controlled through a well-defined interface. To relate this to the real world, consider the automatic transmission on an automobile. It encapsulates hundreds of bits of information about your engine, such as how much you are accelerating, 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 Chapter 2: An Overview of Java this complex encapsulation: by moving the gear-shift lever.
Thus, the gear-shift lever is a well-defined indeed, unique interface to the transmission. Further, what occurs inside the transmission does not affect objects outside the transmission.
For example, shifting gears does not turn on the headlights! Because an automatic transmission is encapsulated, dozens of car manufacturers can implement one in any way they please. This same idea can be applied to programming. The power of encapsulated code is that everyone knows how to access it and thus can use it regardless 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 in great detail later in this book, the following brief discussion will be helpful now.
A class defines 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, as if it were stamped out by a mold in the shape of the class.
For this reason, objects are sometimes referred to as instances of a class. Thus, a class is a logical construct; an object has physical reality. 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 data defined by the class are referred to as member variables or instance variables.
The code that operates on that data is referred to as member methods or just methods. In properly written Java programs, the methods define how the member variables can be used. This means that the behavior and interface 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 for hiding the complexity of the implementation inside the class. Each method or variable in a class may be marked private or public. The public interface of a class represents everything that external users of the class need to know, or may know. The private methods 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 private method or variable.
Of course, this means that the public interface should be carefully designed not to expose too much of the inner workings of a class see Figure Inheritance Inheritance is the process by which one object acquires the properties of another object. This is important because it supports the concept of hierarchical classification. As mentioned 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. Without the 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 it unique within its class. It can inherit its general attributes from its parent.
Thus, it is the inheritance mechanism that makes it possible for one object to be a specific instance of a more general case. If you wanted to describe animals 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 class definition for animals. If you wanted to describe a more specific class of animals, such as mammals, they would have more specific attributes, such as type of teeth, and mammary glands.
Since mammals are simply more precisely specified animals, they inherit all of the attributes from animals. A deeply inherited subclass inherits all of the attributes from each of its ancestors in the class hierarchy.
Chapter 2: An Overview of Java Inheritance interacts with encapsulation as well. If a given class encapsulates some attributes, then any subclass will have the same attributes plus any that it adds as part of its specialization see Figure This is a key concept that lets object-oriented programs grow in complexity linearly rather than geometrically.
A new subclass inherits all of the attributes of all of its ancestors. It does not have unpredictable interactions with the majority of the rest of the code in the system. Consider a stack which is a last-in, first-out list. You might have a program that requires three types of stacks. One stack is used for integer values, one for floating-point values, and one for characters.
The algorithm that implements 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 stack routines, with each set using different names.
However, because of polymorphism, in Java you can specify a general set of stack routines that all share the same names. This helps reduce complexity by allowing the same interface to be used to specify a general class of action. You, the programmer, do not need to make this selection manually. You need only remember and utilize the general interface. 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. The same sense of smell is at work in both situations. This same general concept can be implemented in Java as it applies to methods within a Java program.
James Holmes is a leading Struts authority. He is a committer on the Struts project and creator of the most popular Struts development tool, Struts Console. For information on retaining James for Struts and Java development projects, contact him via e-mail at james jamesholmes.
Bill Siggelkow is a systems development and design consultant who specializes in enterprise-caliber Java-based applications. Bill is an active member of the Atlanta Struts User Group and frequently serves as a presenter for the group. With nearly 20 years of development experience, he has designed and developed systems for the manufacturing, energy marketing, e-commerce, and financial service industries.
Bill enjoys training and mentoring developers in the art of programming. James Mitchell is a self-described 'Open Source Evangelist' and can be found roaming the halls of the Apache and Sourceforge mailing lists.
He is one of a handful of committers on the Struts project at Apache. James is currently working as an independent consultant in the Atlanta, GA, area specializing in Struts-based J2EE application development and is available on a contract basis.
James has built Struts-based enterprise applications in B2B, banking, industrial, and telecommunications industries. For more information or to contact James Mitchell, send your inquiries to jmitchell apache. His programming books have sold more than 3 million copies worldwide and have been translated into all major foreign languages. Schildt holds a master's degree in computer science from the University of Illinois. Writing this book has been one of the most challenging endeavors I've taken on and it would not have been possible without the help and support from several people.
In particular, I want to thank Wendy Rinaldi for giving me the opportunity to write this book and for introducing me to and giving me the opportunity to work with Herb Schildt, whom I'd also like to thank. Not only has Herb been the editor on this book, providing me with endless insight and wisdom, he has become a great friend and a mentor.
Thank you all! Special thanks also to Bill Siggelkow for providing the initial drafts for Chapters 19 and His efforts are sincerely appreciated. Previous page.
0コメント