book

Hardcore Java

Name: Hardcore Java
Author: Robert Simmons
ISBN: 9780596005689

by Robert Simmons

March 2004

Intermediate to advanced

344 pages

8h 50m

English

O'Reilly Media, Inc.

Read now

Unlock full access

A Note Regarding Supplemental Files
Preface
AudiencePrerequisites and AssumptionsTypographical ConventionsCode SamplesLocating an Example in the Downloadable CodeCategories of ExamplesSyntax checkersDemonstratorsExecutablesToolsUML DiagrammingIDEOut-of-IDE BuildingLoggingJakarta CommonsUsing Code ExamplesComments and QuestionsAcknowledgments
1. Java in Review
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. The Final Story
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. Immutable Types
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. Collections
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. Exceptional Code
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. Nested Classes
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. All About Constants
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. Data Modeling
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. Practical Reflection
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. Proxies
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. References in Four Flavors
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. Tiger: JDK 1.5
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
About the Author
Colophon
Copyright

Content preview from Hardcore Java

Chapter 11. References in Four Flavors

The java.lang.ref package is criminally underused in Java programming. Despite the enormous power of the classes within this package, you rarely see them in mainstream coding. Most likely, this is because using these classes properly requires a fairly deep understanding of the garbage-collection infrastructure in Java. However, once you understand garbage collection, you can create code that uses resources efficiently.

The Problem

One of the critical problems in the Online Only Bank data model from Chapter 8 is the high potential for memory leaks. In fact, the process of garbage collection is not enough to protect you from memory leaks. Garbage collection protects you from only one kind of memory leak, known as a lost pointer.

In languages such as C++, a memory leak resembles a lost pointer to an allocated block of memory. In this scenario, an object asks the runtime environment to allocate a block of memory. However, after this allocation, the pointer to the block is lost, perhaps through method return. There is a memory leak because there is a dead stack of allocated memory that the computer cannot use and to which the program can no longer get a pointer. In Java, this type of memory leak is not possible.

However, Java suffers from a different type of memory leak based on the garbage-collection paradigm itself. Since all objects in Java are references, they form an intricate web of associations; these associations can cause a memory leak. ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 0596005687Errata Page

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Hardcore Java

by Robert Simmons

Chapter 11. References in Four Flavors

The Problem

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.