Tài liệu Effective Java: Programming Language Guide ppt

180 355 0
  • Loading ...
1/180 trang
Tải xuống

Thông tin tài liệu

Ngày đăng: 12/12/2013, 21:16

Effective Java: Programming Language Guide Joshua Bloch Publisher: Addison Wesley First Edition June 01, 2001 ISBN: 0-201-31005-8, 272 pages Are you ready for a concise book packed with insight and wisdom not found elsewhere? Do you want to gain a deeper understanding of the Java programming language? Do you want to write code that is clear, correct, robust, and reusable? Look no further! This book will provide you with these and many other benefits you may not even know you were looking for. Featuring fifty-seven valuable rules of thumb, Effective Java Programming Language Guide contains working solutions to the programming challenges most developers encounter each day. Offering comprehensive descriptions of techniques used by the experts who developed the Java platform, this book reveals what to do - and what not to do - in order to produce clear, robust and efficient code. Table of Contents Foreword . 1 Preface . 3 Acknowledgments .4 Chapter 1. Introduction . 5 Chapter 2. Creating and Destroying Objects 8 Item 1: Consider providing static factory methods instead of constructors . 8 Item 2: Enforce the singleton property with a private constructor . 11 Item 3: Enforce noninstantiability with a private constructor 13 Item 4: Avoid creating duplicate objects 13 Item 5: Eliminate obsolete object references . 16 Item 6: Avoid finalizers 19 Chapter 3. Methods Common to All Objects 23 Item 7: Obey the general contract when overriding equals 23 Item 8: Always override hashCode when you override equals 31 Item 9: Always override toString 35 Item 10: Override clone judiciously . 37 Item 11: Consider implementing Comparable . 44 Chapter 4. Classes and Interfaces . 48 Item 12: Minimize the accessibility of classes and members 48 Item 13: Favor immutability 50 Item 14: Favor composition over inheritance 57 Item 15: Design and document for inheritance or else prohibit it 61 Item 16: Prefer interfaces to abstract classes . 65 Item 17: Use interfaces only to define types 69 Item 18: Favor static member classes over nonstatic . 71 Chapter 5. Substitutes for C Constructs 75 Item 19: Replace structures with classes 75 Item 20: Replace unions with class hierarchies . 76 Item 21: Replace enum constructs with classes 80 Item 22: Replace function pointers with classes and interfaces . 88 Chapter 6. Methods 91 Item 23: Check parameters for validity 91 Item 24: Make defensive copies when needed . 93 Item 25: Design method signatures carefully . 96 Item 26: Use overloading judiciously 97 Item 27: Return zero-length arrays, not nulls . 101 Item 28: Write doc comments for all exposed API elements . 103 Chapter 7. General Programming 107 Item 29: Minimize the scope of local variables . 107 Item 30: Know and use the libraries . 109 Item 31: Avoid float and double if exact answers are required 112 Item 32: Avoid strings where other types are more appropriate 114 Item 33: Beware the performance of string concatenation 116 Item 34: Refer to objects by their interfaces 117 Item 35: Prefer interfaces to reflection . 118 Item 36: Use native methods judiciously . 121 Item 37: Optimize judiciously 122 Item 38: Adhere to generally accepted naming conventions . 124 Chapter 8. Exceptions 127 Item 39:Use exceptions only for exceptional conditions . 127 Item 40:Use checked exceptions for recoverable conditions and run-time exceptions for programming errors 129 Item 41:Avoid unnecessary use of checked exceptions . 130 Item 42:Favor the use of standard exceptions 132 Item 43: Throw exceptions appropriate to the abstraction . 133 Item 44:Document all exceptions thrown by each method 135 Item 45:Include failure-capture information in detail messages 136 Item 46:Strive for </vetbfailure atomicity . 138 Item 47:Don't ignore exceptions 139 Chapter 9. Threads 141 Item 48: Synchronize access to shared mutable data . 141 Item 49: Avoid excessive synchronization . 145 Item 50: Never invoke wait outside a loop . 149 Item 51: Don't depend on the thread scheduler 151 Item 52: Document thread safety . 154 Item 53: Avoid thread groups . 156 Chapter 10. Serialization . 158 Item 54: Implement Serializable judiciously 158 Item 55:Consider using a custom serialized form 161 Item 56:Write readObject methods defensively 166 Item 57: Provide a readResolve method when necessary 171 References . 174 Effective Java: Programming Language Guide 1 Foreword If a colleague were to say to you, “Spouse of me this night today manufactures the unusual meal in a home. You will join?” three things would likely cross your mind: third, that you had been invited to dinner; second, that English was not your colleague's first language; and first, a good deal of puzzlement. If you have ever studied a second language yourself and then tried to use it outside the classroom, you know that there are three things you must master: how the language is structured (grammar), how to name things you want to talk about (vocabulary), and the customary and effective ways to say everyday things (usage). Too often only the first two are covered in the classroom, and you find native speakers constantly suppressing their laughter as you try to make yourself understood. It is much the same with a programming language. You need to understand the core language: is it algorithmic, functional, object-oriented? You need to know the vocabulary: what data structures, operations, and facilities are provided by the standard libraries? And you need to be familiar with the customary and effective ways to structure your code. Books about programming languages often cover only the first two, or discuss usage only spottily. Maybe that's because the first two are in some ways easier to write about. Grammar and vocabulary are properties of the language alone, but usage is characteristic of a community that uses it. The Java programming language, for example, is object-oriented with single inheritance and supports an imperative (statement-oriented) coding style within each method. The libraries address graphic display support, networking, distributed computing, and security. But how is the language best put to use in practice? There is another point. Programs, unlike spoken sentences and unlike most books and magazines, are likely to be changed over time. It's typically not enough to produce code that operates effectively and is readily understood by other persons; one must also organize the code so that it is easy to modify. There may be ten ways to write code for some task T. Of those ten ways, seven will be awkward, inefficient, or puzzling. Of the other three, which is most likely to be similar to the code needed for the task T' in next year's software release? There are numerous books from which you can learn the grammar of the Java Programming Language, including The Java Programming Language by Arnold, Gosling, and Holmes [Arnold00] or The Java Language Specification by Gosling, Joy, yours truly, and Bracha [JLS]. Likewise, there are dozens of books on the libraries and APIs associated with the Java programming language. This book addresses your third need: customary and effective usage. Joshua Bloch has spent years extending, implementing, and using the Java programming language at Sun Microsystems; he has also read a lot of other people's code, including mine. Here he offers good advice, systematically organized, on how to structure your code so that it works well, so that other people can understand it, so that future modifications and improvements are less Effective Java: Programming Language Guide 2 likely to cause headaches—perhaps, even, so that your programs will be pleasant, elegant, and graceful. Guy L. Steele Jr. Burlington, Massachusetts April 2001 Effective Java: Programming Language Guide 3 Preface In 1996 I pulled up stakes and headed west to work for JavaSoft, as it was then known, because it was clear that that was where the action was. In the intervening five years I've served as Java platform libraries architect. I've designed, implemented, and maintained many of the libraries and served as a consultant for many others. Presiding over these libraries as the Java platform matured was a once-in-a-lifetime opportunity. It is no exaggeration to say that I had the privilege to work with some of the great software engineers of our generation. In the process, I learned a lot about the Java programming language—what works, what doesn't, and how to use the language and its libraries to best effect. This book is my attempt to share my experience with you so that you can imitate my successes while avoiding my failures. I borrowed the format from Scott Meyers's Effective C++ [Meyers98], which consists of fifty items, each conveying one specific rule for improving your programs and designs. I found the format to be singularly effective, and I hope you do too. In many cases, I took the liberty of illustrating the items with real-world examples from the Java platform libraries. When describing something that could have been done better, I tried to pick on code that I wrote myself, but occasionally I pick on something written by a colleague. I sincerely apologize if, despite my best efforts, I've offended anyone. Negative examples are cited not to cast blame but in the spirit of cooperation, so that all of us can benefit from the experience of those who've gone before. While this book is not targeted solely at developers of reusable components, it is inevitably colored by my experience writing such components over the past two decades. I naturally think in terms of exported APIs (Application Programming Interfaces), and I encourage you to do likewise. Even if you aren't developing reusable components, thinking in these terms tends to improve the quality of the software you write. Furthermore, it's not uncommon to write a reusable component without knowing it: You write something useful, share it with your buddy across the hall, and before long you have half a dozen users. At this point, you no longer have the flexibility to change the API at will and are thankful for all the effort that you put into designing the API when you first wrote the software. My focus on API design may seem a bit unnatural to devotees of the new lightweight software development methodologies, such as Extreme Programming [Beck99]. These methodologies emphasize writing the simplest program that could possibly work. If you're using one of these methodologies, you'll find that a focus on API design serves you well in the refactoring process. The fundamental goals of refactoring are the improvement of system structure and the avoidance of code duplication. These goals are impossible to achieve in the absence of well-designed APIs for the components of the system. No language is perfect, but some are excellent. I have found the Java programming language and its libraries to be immensely conducive to quality and productivity, and a joy to work with. I hope this book captures my enthusiasm and helps make your use of the language more effective and enjoyable. Joshua Bloch Cupertino, California April 2001 Effective Java: Programming Language Guide 4 Acknowledgments I thank Patrick Chan for suggesting that I write this book and for pitching the idea to Lisa Friendly, the series managing editor; Tim Lindholm, the series technical editor; and Mike Hendrickson, executive editor of Addison-Wesley Professional. I thank Lisa, Tim, and Mike for encouraging me to pursue the project and for their superhuman patience and unyielding faith that I would someday write this book. I thank James Gosling and his original team for giving me something great to write about, and I thank the many Java platform engineers who followed in James's footsteps. In particular, I thank my colleagues in Sun's Java Platform Tools and Libraries Group for their insights, their encouragement, and their support. The team consists of Andrew Bennett, Joe Darcy, Neal Gafter, Iris Garcia, Konstantin Kladko, Ian Little, Mike McCloskey, and Mark Reinhold. Former members include Zhenghua Li, Bill Maddox, and Naveen Sanjeeva. I thank my manager, Andrew Bennett, and my director, Larry Abrahams, for lending their full and enthusiastic support to this project. I thank Rich Green, the VP of Engineering at Java Software, for providing an environment where engineers are free to think creatively and to publish their work. I have been blessed with the best team of reviewers imaginable, and I give my sincerest thanks to each of them: Andrew Bennett, Cindy Bloch, Dan Bloch, Beth Bottos, Joe Bowbeer, Gilad Bracha, Mary Campione, Joe Darcy, David Eckhardt, Joe Fialli, Lisa Friendly, James Gosling, Peter Haggar, Brian Kernighan, Konstantin Kladko, Doug Lea, Zhenghua Li, Tim Lindholm, Mike McCloskey, Tim Peierls, Mark Reinhold, Ken Russell, Bill Shannon, Peter Stout, Phil Wadler, and two anonymous reviewers. They made numerous suggestions that led to great improvements in this book and saved me from many embarrassments. Any remaining embarrassments are my responsibility. Numerous colleagues, inside and outside Sun, participated in technical discussions that improved the quality of this book. Among others, Ben Gomes, Steffen Grarup, Peter Kessler, Richard Roda, John Rose, and David Stoutamire contributed useful insights. A special thanks is due Doug Lea, who served as a sounding board for many of the ideas in this book. Doug has been unfailingly generous with his time and his knowledge. I thank Julie Dinicola, Jacqui Doucette, Mike Hendrickson, Heather Olszyk, Tracy Russ, and the whole team at Addison-Wesley for their support and professionalism. Even under an impossibly tight schedule, they were always friendly and accommodating. I thank Guy Steele for writing the foreword. I am honored that he chose to participate in this project. Finally, I thank my wife, Cindy Bloch, for encouraging and occasionally threatening me to write this book, for reading each item in its raw form, for helping me with Framemaker, for writing the index, and for putting up with me while I wrote. Effective Java: Programming Language Guide 5 Chapter 1. Introduction This book is designed to help you make the most effective use of the Java™ programming language and its fundamental libraries, java.lang , java.util , and, to a lesser extent, java.io . The book discusses other libraries from time to time, but it does not cover graphical user interface programming or enterprise APIs. This book consists of fifty-seven items, each of which conveys one rule. The rules capture practices generally held to be beneficial by the best and most experienced programmers. The items are loosely grouped into nine chapters, each concerning one broad aspect of software design. The book is not intended to be read from cover to cover: Each item stands on its own, more or less. The items are heavily cross-referenced so you can easily plot your own course through the book. Most items are illustrated with program examples. A key feature of this book is that it contains code examples illustrating many design patterns and idioms. Some are old, like Singleton (Item 2), and others are new, like Finalizer Guardian (Item 6) and Defensive readResolve (Item 57). A separate index is provided for easy access to these patterns and idioms (page 239). Where appropriate, they are cross-referenced to the standard reference work in this area [Gamma95]. Many items contain one or more program examples illustrating some practice to be avoided. Such examples, sometimes known as antipatterns, are clearly labeled with a comment such as “ // Never do this! ” In each case, the item explains why the example is bad and suggests an alternative approach. This book is not for beginners: it assumes that you are already comfortable with the Java programming language. If you are not, consider one of the many fine introductory texts [Arnold00, Campione00]. While the book is designed to be accessible to anyone with a working knowledge of the language, it should provide food for thought even for advanced programmers. Most of the rules in this book derive from a few fundamental principles. Clarity and simplicity are of paramount importance. The user of a module should never be surprised by its behavior. Modules should be as small as possible but no smaller. (As used in this book, the term module refers to any reusable software component, from an individual method to a complex system consisting of multiple packages.) Code should be reused rather than copied. The dependencies between modules should be kept to a minimum. Errors should be detected as soon as possible after they are made, ideally at compile time. While the rules in this book do not apply 100 percent of the time, they do characterize best programming practices in the great majority of cases. You should not slavishly follow these rules, but you should violate them only occasionally and with good reason. Learning the art of programming, like most other disciplines, consists of first learning the rules and then learning when to violate them. For the most part, this book is not about performance. It is about writing programs that are clear, correct, usable, robust, flexible, and maintainable. If you can do that, it's usually a relatively simple matter to get the performance you need (Item 37). Some items do discuss performance concerns, and a few of these items provide performance numbers. These Effective Java: Programming Language Guide 6 numbers, which are introduced with the phrase “On my machine,” should be regarded as approximate at best. For what it's worth, my machine is an aging homebuilt 400 MHz Pentium® II with 128 megabytes of RAM, running Sun's 1.3 release of the Java 2 Standard Edition Software Development Kit (SDK) atop Microsoft Windows NT® 4.0. This SDK includes Sun's Java HotSpot™ Client VM, a state-of-the-art JVM implementation designed for client use. When discussing features of the Java programming language and its libraries, it is sometimes necessary to refer to specific releases. For brevity, this book uses “engineering version numbers” in preference to official release names. Table 1.1 shows the correspondence between release names and engineering version numbers. Table 1.1. Java Platform Versions Official Release Name Engineering Version Number JDK 1.1.x / JRE 1.1.x 1.1 Java 2 Platform, Standard Edition, v 1.2 1.2 Java 2 Platform, Standard Edition, v 1.3 1.3 Java 2 Platform, Standard Edition, v 1.4 1.4 While features introduced in the 1.4 release are discussed in some items, program examples, with very few exceptions, refrain from using these features. The examples have been tested on releases 1.3. Most, if not all, of them should run without modification on release 1.2. The examples are reasonably complete, but they favor readability over completeness. They freely use classes from the packages java.util and java.io . In order to compile the examples, you may have to add one or both of these import statements: import java.util.*; import java.io.*; Other boilerplate is similarly omitted. The book's Web site, http://java.sun.com/docs/books/effective, contains an expanded version of each example, which you can compile and run. For the most part, this book uses technical terms as they are defined in The Java Language Specification, Second Edition [JLS]. A few terms deserve special mention. The language supports four kinds of types: interfaces, classes, arrays, and primitives. The first three are known as reference types. Class instances and arrays are objects; primitive values are not. A class's members consist of its fields, methods, member classes, and member interfaces. A method's signature consists of its name and the types of its formal parameters; the signature does not include the method's return type. This book uses a few terms differently from the The Java Language Specification. Unlike The Java Language Specification, this book uses inheritance as a synonym for subclassing. Instead of using the term inheritance for interfaces, this book simply states that a class implements an interface or that one interface extends another. To describe the access level that applies when none is specified, this book uses the descriptive term package-private instead of the technically correct term default access [JLS, 6.6.1]. [...].. .Effective Java: Programming Language Guide This book uses a few technical terms that are not defined in The Java Language Specification The term exported API, or simply API, refers to the classes, interfaces, constructors, members, and serialized forms by which a programmer accesses a class, interface, or package (The term API, which is short for application programming interface,... conventions These conventions are still evolving, but two names for static factory methods are becoming common: 10 Effective Java: Programming Language Guide • • valueOf— Returns an instance that has, loosely speaking, the same value as its parameters Static factory methods with this name are effectively type-conversion operators getInstance— Returns an instance that is described by its parameters but... required to create a new object each time they're invoked This allows immutable classes (Item 13) to use preconstructed instances or to cache instances as they're constructed and to 8 Effective Java: Programming Language Guide dispense these instances repeatedly so as to avoid creating unnecessary duplicate objects The Boolean.valueOf(boolean) method illustrates this technique: It never creates an object... mechanism is provided to register these implementations, making them available for use Clients of the framework use the API without worrying about which implementation they are using 9 Effective Java: Programming Language Guide In the JCE, the system administrator registers an implementation class by editing a wellknown Properties file, adding an entry that maps a string key to the corresponding class... default mode of operation Loosely speaking, the exported API of a package consists of the public and protected members and constructors of every public class or interface in the package 7 Effective Java: Programming Language Guide Chapter 2 Creating and Destroying Objects This chapter concerns creating and destroying objects: when and how to create objects, when and how to avoid creating them, how to ensure... initialized—no more, no less Nothing that a client does can change this In a second approach, a public static factory method is provided instead of the public static final field: 11 Effective Java: Programming Language Guide // Singleton with static factory public class Elvis { private static final Elvis INSTANCE = new Elvis(); private Elvis() { } public static Elvis getInstance() { return INSTANCE;... new instances of the relevant class are created after it is initialized In the case of this item, only a single instance of the class is created; in Item 21, one instance is created 12 Effective Java: Programming Language Guide for each member of the enumerated type In the next item (Item 3), this approach is taken one step further: the absence of a public constructor is used to ensure that no instances... instead of creating a new functionally equivalent object each time it is needed Reuse can be both faster and more stylish An object can always be reused if it is immutable (Item 13) 13 Effective Java: Programming Language Guide As an extreme example of what not to do, consider this statement: String s = new String("silly"); // DON'T DO THIS! The statement creates a new String instance each time it is... gmtCal.getTime(); gmtCal.set(1965, Calendar.JANUARY, 1, 0, 0, 0); Date boomEnd = gmtCal.getTime(); return birthDate.compareTo(boomStart) >= 0 && birthDate.compareTo(boomEnd) < 0; } 14 Effective Java: Programming Language Guide The isBabyBoomer method unnecessarily creates a new Calendar, TimeZone, and two Date instances each time it is invoked The version that follows avoids this inefficiency with a... Consider the case of adapters [Gamma98, p 139], also known as views An adapter is one object that delegates to a backing object, providing an alternative interface to the backing 15 Effective Java: Programming Language Guide object Because an adapter has no state beyond that of its backing object, there's no need to create more than one instance of a given adapter to a given object For example, the . your use of the language more effective and enjoyable. Joshua Bloch Cupertino, California April 2001 Effective Java: Programming Language Guide 4 Acknowledgments. wrote. Effective Java: Programming Language Guide 5 Chapter 1. Introduction This book is designed to help you make the most effective use of the Java™ programming
- Xem thêm -

Xem thêm: Tài liệu Effective Java: Programming Language Guide ppt, Tài liệu Effective Java: Programming Language Guide ppt, Tài liệu Effective Java: Programming Language Guide ppt

Từ khóa liên quan

Gợi ý tài liệu liên quan cho bạn

Nhận lời giải ngay chưa đến 10 phút Đăng bài tập ngay