book

Hardcore Java

by Robert Simmons

March 2004

Intermediate to advanced

344 pages

8h 50m

English

O'Reilly Media, Inc.

Read now

Unlock full access

AudiencePrerequisites and AssumptionsTypographical ConventionsCode SamplesLocating an Example in the Downloadable CodeCategories of ExamplesSyntax checkersDemonstratorsExecutablesToolsUML DiagrammingIDEOut-of-IDE BuildingLoggingJakarta CommonsUsing Code ExamplesComments and QuestionsAcknowledgments
1.1. Core Concepts1.1.1. Constant Problems with Pointers1.1.2. Everything Is a Class and Object Is God1.1.3. RTTI1.2. Syntax Issues1.2.1. Abbreviated if1.2.2. Ternary Expressions1.2.3. Leveraging for Loops1.2.3.1. for loop fundamentals1.2.3.2. Collection iteration with for1.2.4. Abrupt Flow Control1.2.4.1. break1.2.4.2. continue1.2.4.3. Labels1.2.5. assert1.2.5.1. Assertions versus exceptions1.2.5.2. To assert or not to assert1.2.5.3. Assertions and deployment1.2.6. Chaining Constructors1.2.7. Initialization1.3. Access Issues1.3.1. Preferred Restrictions1.3.2. Friends Allow Unrestricted Access1.4. Common Mistakes1.4.1. System Streams1.4.2. System.exit( )1.4.3. Default Execution
2.1. Final Constants2.1.1. Public Primitives and Substitution2.1.2. Excessive Constants2.2. Final Variables2.2.1. Method-Scoped final Variables2.2.2. Deferred Initialization2.2.2.1. Chained deferred initialization2.3. Final Parameters2.4. Final Collections2.5. Instance-Scoped Variables2.6. Final Classes2.7. Final Methods2.8. Conditional Compilation2.8.1. Conditional Compilation Variable Location2.9. Using final as a Coding Standard
3.1. Fundamentals3.1.1. Creating Immutable Types3.1.2. Cracked Immutables3.1.3. False Immutable Types3.2. Immutable Problems3.2.1. The String Trap3.2.2. Buffering Bad Performance3.3. Immutable or Not
4.1. Collection Concepts4.1.1. An Interface-Based Approach4.1.2. Collection Types4.1.2.1. Maps4.1.2.2. Collections4.2. Implementations4.2.1. Determining Equality and Order4.2.1.1. Equality versus identity4.2.1.2. Comparing objects4.2.2. Big O Notation4.2.3. Lists4.2.3.1. java.util.Vector4.2.3.2. java.util.ArrayList4.2.3.3. java.util.LinkedList4.2.4. Maps and SortedMaps4.2.4.1. java.util.HashTable4.2.4.2. java.util.HashMap4.2.4.3. java.util.LinkedHashMap4.2.4.4. java.util.IdentityHashMap4.2.4.5. java.util.WeakHashMap4.2.4.6. java.util.TreeMap4.2.5. Sets and SortedSets4.2.5.1. java.util.HashSet4.2.5.2. java.util.LinkedSet4.2.5.3. java.util.TreeSet4.3. Choosing a Collection Type4.4. Iterating Collections4.4.1. Three Iterators4.4.1.1. java.util.Enumeration4.4.1.2. java.util.Iterator4.4.1.3. java.util.ListIterator4.4.2. Fail-Fast Iterators4.5. Collection Gotchas4.5.1. Storage by Reference4.5.2. Failure to Override hashCode( )4.5.3. Lack of Type Safety4.5.4. Collecting Problems
5.1. Two Types of Exceptions5.1.1. The Exception Subclasses5.1.1.1. Superfluous exceptions5.1.2. The RuntimeException Subclasses5.1.2.1. Masking exceptions5.1.2.2. Ignoring exceptions5.1.3. Exception or RuntimeException5.2. When to Use Exceptions5.2.1. Forgetting Exceptions5.2.2. Too Many Exceptions5.3. Finally for Closure5.4. Exceptional Traps
6.1. Inner Classes6.1.1. Hierarchies of Inner Classes6.2. Limited-Scope Inner Classes6.2.1. Anonymous Classes6.2.1.1. Anonymous class syntax6.2.2. Problems with Limited-Scope Inner Classes6.3. Static Nested Classes6.4. Double Nested Classes6.5. Nested Classes in Interfaces?6.6. Nested Interfaces6.6.1. Nested Interfaces in Classes6.6.2. Nested Interfaces in Interfaces6.7. Nested Class Rules
7.1. Substitution Constants7.1.1. Internationalizing with Substitution Constants7.1.1.1. Common internationalization techniques7.1.1.2. Improving internationalization performance7.2. Bit Fields7.2.1. Altering Bit Fields7.2.2. Comparing Bit Fields7.2.3. Problems with Bit Fields7.2.3.1. Mutual exclusivity7.2.3.2. Limited expandability7.2.3.3. Improper encapsulation7.3. Option Constants7.3.1. Defects of Option Constants7.4. Constant Objects7.4.1. Performance of Constant Objects7.4.2. Indexing Constant Objects7.4.3. Serialized Constant Objects7.4.4. Accounting for Multiple Constant Object Types7.5. Constant Encapsulation
8.1. The Requirements Document8.1.1. An Iterative Process8.1.2. Getting Approval of Requirements8.1.3. Closing the Gap8.2. Natural Language Modeling8.2.1. Noun Sets8.2.2. An Application of Natural Language Modeling8.2.2.1. Creating the noun set8.2.2.2. Moving to a data model8.2.2.3. Relationships and attributes8.2.2.4. The first draft8.3. Aspects of Well-Designed Data Models8.3.1. Ghost Classes8.3.2. Proper Relationships8.3.2.1. Is a8.3.2.2. Has a8.3.2.3. Uses a8.3.3. A Primitive Question8.3.3.1. Partial use of primitives8.3.3.2. Using only wrapper types8.3.4. Mutable Objects8.3.4.1. Identity and equality for all objects8.4. Reusable Data Constraints8.4.1. The ConstraintException8.4.2. The Constraint Hierarchy8.4.2.1. Primitive constraints8.4.2.2. Object constraints8.4.2.3. A numerical object constraint8.4.2.4. Constraints for collections8.4.3. Using Constraints8.4.4. Creating New Constraint Types8.5. Persistence8.5.1. RDBMS Versus OODBMS8.5.2. Java Data Objects to the Rescue

9.1. The Basics9.2. Reflection and Greater Reflection9.2.1. Package java.lang9.2.1.1. Class java.lang.Class9.2.1.2. Class java.lang.Object9.2.1.3. Class java.lang.Package9.2.2. Package java.lang.reflect9.2.2.1. Class java.lang.reflect.Field9.2.2.2. Class java.lang.reflect.Method9.2.2.3. Class java.lang.reflect.Modifier9.2.2.4. Class java.lang.reflect.Proxy9.2.2.5. Class java.lang.reflect.AccessibleObject9.2.3. Package java.beans9.2.3.1. Class java.beans.Introspector9.2.3.2. Class java.beans.PropertyDescriptor9.2.3.3. Class java.beans.IndexedPropertyDescriptor9.2.3.4. Classes MethodDescriptor and ParameterDescriptor9.2.3.5. Interface java.beans.BeanInfo9.3. Applying Reflection to MutableObject9.3.1. Reflecting on toString( )9.3.2. Fetching Constraints9.4. Performance of Reflection9.5. Reflection + JUnit = Stable Code
10.1. What Is a Proxy?10.1.1. Network Proxies and CORBA10.1.2. Factories10.1.3. Client and Server Objects10.2. Two Kinds of Proxies10.2.1. Static Proxies10.2.2. Proxy by Interface10.2.3. Dynamic Proxies10.2.3.1. Invocation handlers10.2.3.2. Generated proxy classes10.2.3.3. Using dynamic proxies10.3. Proxy Gotchas
11.1. The Problem11.2. Java Reference Concepts11.2.1. Strong References11.2.2. Weak References11.2.3. Soft References11.2.4. Phantom References11.2.5. References and Referents11.2.6. Reference Queues11.2.7. The Garbage-Collection Process11.3. The Java Reference Classes11.3.1. Reference Classes11.3.1.1. java.lang.ref.Reference11.3.1.2. java.lang.ref.WeakReference11.3.1.3. java.lang.ref.SoftReference11.3.1.4. java.lang.ref.PhantomReference11.3.2. Reference Queues11.4. Practical Applications11.4.1. A Weak Collection11.4.2. Testing WeakHashSet11.5. A Weak Listener11.6. When to Use References
12.1. New Language Features12.1.1. For Each12.1.2. Autoboxing with Variables12.1.2.1. Implicit casting12.1.2.2. Ambiguous autoboxing12.1.3. Enums12.1.3.1. Adding functionality to enums12.1.3.2. Interfaces and hierarchies12.1.4. Static Imports12.1.5. Variable Arguments12.2. Generics12.2.1. The Syntax of Generics12.2.1.1. Nested generics12.2.1.2. Multi-generics12.2.1.3. Bounds12.2.1.4. Wildcards12.2.1.5. Lower bounds12.2.1.6. Raw types12.2.2. Erasure12.2.2.1. Cracking type safety12.2.3. Casting Generics12.2.4. Generic Methods12.2.5. Inference12.2.5.1. Simple generic inference12.2.5.2. Masking methods with inference12.2.5.3. Inference based on return type12.2.5.4. Generic parameter-based inference12.2.5.5. Context-sensitive inference12.2.5.6. Avoiding inference through explicit declaration12.2.6. Generic Gotchas12.2.6.1. Going overboard12.2.6.2. Compile-time class conformance12.3. Other Improvements in Tiger

Content preview from Hardcore Java

About the Author

Robert Simmons, Jr. started programming when floppy disks were really floppy and 64 kilobytes of RAM was considered state of the art. From his early days of programming BASIC and Logo on an Apple IIe, he advanced through Pascal and C to arrive in the object oriented realm of C++. When Java first came out, he knew that the infant language would become a serious player amongst corporations; Robert learned Java and began using it as his primary language for programming in 1997. Although Robert is American, he lives and works as a Senior Software Architect in Germany.