Hardcore Java

Spis treści książki

• Hardcore Java
  • SPECIAL OFFER: Upgrade this ebook with OReilly
  • A Note Regarding Supplemental Files
  • Preface
    • Audience
      • Prerequisites and Assumptions
    • Typographical Conventions
    • Code Samples
      • Locating an Example in the Downloadable Code
      • Categories of Examples
        • Syntax checkers
        • Demonstrators
        • Executables
    • Tools
      • UML Diagramming
      • IDE
      • Out-of-IDE Building
      • Logging
      • Jakarta Commons
    • Using Code Examples
    • Comments and Questions
    • Acknowledgments
  • 1. Java in Review
    • 1.1. Core Concepts
      • 1.1.1. Constant Problems with Pointers
      • 1.1.2. Everything Is a Class and Object Is God
      • 1.1.3. RTTI
    • 1.2. Syntax Issues
      • 1.2.1. Abbreviated if
      • 1.2.2. Ternary Expressions
      • 1.2.3. Leveraging for Loops
        • 1.2.3.1. for loop fundamentals
        • 1.2.3.2. Collection iteration with for
      • 1.2.4. Abrupt Flow Control
        • 1.2.4.1. break
        • 1.2.4.2. continue
        • 1.2.4.3. Labels
      • 1.2.5. assert
        • 1.2.5.1. Assertions versus exceptions
        • 1.2.5.2. To assert or not to assert
        • 1.2.5.3. Assertions and deployment
      • 1.2.6. Chaining Constructors
      • 1.2.7. Initialization
    • 1.3. Access Issues
      • 1.3.1. Preferred Restrictions
      • 1.3.2. Friends Allow Unrestricted Access
    • 1.4. Common Mistakes
      • 1.4.1. System Streams
      • 1.4.2. System.exit( )
      • 1.4.3. Default Execution
  • 2. The Final Story
    • 2.1. Final Constants
      • 2.1.1. Public Primitives and Substitution
      • 2.1.2. Excessive Constants
    • 2.2. Final Variables
      • 2.2.1. Method-Scoped final Variables
      • 2.2.2. Deferred Initialization
        • 2.2.2.1. Chained deferred initialization
    • 2.3. Final Parameters
    • 2.4. Final Collections
    • 2.5. Instance-Scoped Variables
    • 2.6. Final Classes
    • 2.7. Final Methods
    • 2.8. Conditional Compilation
      • 2.8.1. Conditional Compilation Variable Location
    • 2.9. Using final as a Coding Standard
  • 3. Immutable Types
    • 3.1. Fundamentals
      • 3.1.1. Creating Immutable Types
      • 3.1.2. Cracked Immutables
      • 3.1.3. False Immutable Types
    • 3.2. Immutable Problems
      • 3.2.1. The String Trap
      • 3.2.2. Buffering Bad Performance
    • 3.3. Immutable or Not
  • 4. Collections
    • 4.1. Collection Concepts
      • 4.1.1. An Interface-Based Approach
      • 4.1.2. Collection Types
        • 4.1.2.1. Maps
        • 4.1.2.2. Collections
    • 4.2. Implementations
      • 4.2.1. Determining Equality and Order
        • 4.2.1.1. Equality versus identity
        • 4.2.1.2. Comparing objects
      • 4.2.2. Big O Notation
      • 4.2.3. Lists
        • 4.2.3.1. java.util.Vector
        • 4.2.3.2. java.util.ArrayList
        • 4.2.3.3. java.util.LinkedList
      • 4.2.4. Maps and SortedMaps
        • 4.2.4.1. java.util.HashTable
        • 4.2.4.2. java.util.HashMap
        • 4.2.4.3. java.util.LinkedHashMap
        • 4.2.4.4. java.util.IdentityHashMap
        • 4.2.4.5. java.util.WeakHashMap
        • 4.2.4.6. java.util.TreeMap
      • 4.2.5. Sets and SortedSets
        • 4.2.5.1. java.util.HashSet
        • 4.2.5.2. java.util.LinkedSet
        • 4.2.5.3. java.util.TreeSet
    • 4.3. Choosing a Collection Type
    • 4.4. Iterating Collections
      • 4.4.1. Three Iterators
        • 4.4.1.1. java.util.Enumeration
        • 4.4.1.2. java.util.Iterator
        • 4.4.1.3. java.util.ListIterator
      • 4.4.2. Fail-Fast Iterators
    • 4.5. Collection Gotchas
      • 4.5.1. Storage by Reference
      • 4.5.2. Failure to Override hashCode( )
      • 4.5.3. Lack of Type Safety
      • 4.5.4. Collecting Problems
  • 5. Exceptional Code
    • 5.1. Two Types of Exceptions
      • 5.1.1. The Exception Subclasses
        • 5.1.1.1. Superfluous exceptions
      • 5.1.2. The RuntimeException Subclasses
        • 5.1.2.1. Masking exceptions
        • 5.1.2.2. Ignoring exceptions
      • 5.1.3. Exception or RuntimeException
    • 5.2. When to Use Exceptions
      • 5.2.1. Forgetting Exceptions
      • 5.2.2. Too Many Exceptions
    • 5.3. Finally for Closure
    • 5.4. Exceptional Traps
  • 6. Nested Classes
    • 6.1. Inner Classes
      • 6.1.1. Hierarchies of Inner Classes
    • 6.2. Limited-Scope Inner Classes
      • 6.2.1. Anonymous Classes
        • 6.2.1.1. Anonymous class syntax
      • 6.2.2. Problems with Limited-Scope Inner Classes
    • 6.3. Static Nested Classes
    • 6.4. Double Nested Classes
    • 6.5. Nested Classes in Interfaces?
    • 6.6. Nested Interfaces
      • 6.6.1. Nested Interfaces in Classes
      • 6.6.2. Nested Interfaces in Interfaces
    • 6.7. Nested Class Rules
  • 7. All About Constants
    • 7.1. Substitution Constants
      • 7.1.1. Internationalizing with Substitution Constants
        • 7.1.1.1. Common internationalization techniques
        • 7.1.1.2. Improving internationalization performance
    • 7.2. Bit Fields
      • 7.2.1. Altering Bit Fields
      • 7.2.2. Comparing Bit Fields
      • 7.2.3. Problems with Bit Fields
        • 7.2.3.1. Mutual exclusivity
        • 7.2.3.2. Limited expandability
        • 7.2.3.3. Improper encapsulation
    • 7.3. Option Constants
      • 7.3.1. Defects of Option Constants
    • 7.4. Constant Objects
      • 7.4.1. Performance of Constant Objects
      • 7.4.2. Indexing Constant Objects
      • 7.4.3. Serialized Constant Objects
      • 7.4.4. Accounting for Multiple Constant Object Types
    • 7.5. Constant Encapsulation
  • 8. Data Modeling
    • 8.1. The Requirements Document
      • 8.1.1. An Iterative Process
      • 8.1.2. Getting Approval of Requirements
      • 8.1.3. Closing the Gap
    • 8.2. Natural Language Modeling
      • 8.2.1. Noun Sets
      • 8.2.2. An Application of Natural Language Modeling
        • 8.2.2.1. Creating the noun set
        • 8.2.2.2. Moving to a data model
        • 8.2.2.3. Relationships and attributes
        • 8.2.2.4. The first draft
    • 8.3. Aspects of Well-Designed Data Models
      • 8.3.1. Ghost Classes
      • 8.3.2. Proper Relationships
        • 8.3.2.1. Is a
        • 8.3.2.2. Has a
        • 8.3.2.3. Uses a
      • 8.3.3. A Primitive Question
        • 8.3.3.1. Partial use of primitives
        • 8.3.3.2. Using only wrapper types
      • 8.3.4. Mutable Objects
        • 8.3.4.1. Identity and equality for all objects
    • 8.4. Reusable Data Constraints
      • 8.4.1. The ConstraintException
      • 8.4.2. The Constraint Hierarchy
        • 8.4.2.1. Primitive constraints
        • 8.4.2.2. Object constraints
        • 8.4.2.3. A numerical object constraint
        • 8.4.2.4. Constraints for collections
      • 8.4.3. Using Constraints
      • 8.4.4. Creating New Constraint Types
    • 8.5. Persistence
      • 8.5.1. RDBMS Versus OODBMS
      • 8.5.2. Java Data Objects to the Rescue
  • 9. Practical Reflection
    • 9.1. The Basics
    • 9.2. Reflection and Greater Reflection
      • 9.2.1. Package java.lang
        • 9.2.1.1. Class java.lang.Class
        • 9.2.1.2. Class java.lang.Object
        • 9.2.1.3. Class java.lang.Package
      • 9.2.2. Package java.lang.reflect
        • 9.2.2.1. Class java.lang.reflect.Field
        • 9.2.2.2. Class java.lang.reflect.Method
        • 9.2.2.3. Class java.lang.reflect.Modifier
        • 9.2.2.4. Class java.lang.reflect.Proxy
        • 9.2.2.5. Class java.lang.reflect.AccessibleObject
      • 9.2.3. Package java.beans
        • 9.2.3.1. Class java.beans.Introspector
        • 9.2.3.2. Class java.beans.PropertyDescriptor
        • 9.2.3.3. Class java.beans.IndexedPropertyDescriptor
        • 9.2.3.4. Classes MethodDescriptor and ParameterDescriptor
        • 9.2.3.5. Interface java.beans.BeanInfo
    • 9.3. Applying Reflection to MutableObject
      • 9.3.1. Reflecting on toString( )
      • 9.3.2. Fetching Constraints
    • 9.4. Performance of Reflection
    • 9.5. Reflection + JUnit = Stable Code
  • 10. Proxies
    • 10.1. What Is a Proxy?
      • 10.1.1. Network Proxies and CORBA
      • 10.1.2. Factories
      • 10.1.3. Client and Server Objects
    • 10.2. Two Kinds of Proxies
      • 10.2.1. Static Proxies
      • 10.2.2. Proxy by Interface
      • 10.2.3. Dynamic Proxies
        • 10.2.3.1. Invocation handlers
        • 10.2.3.2. Generated proxy classes
        • 10.2.3.3. Using dynamic proxies
    • 10.3. Proxy Gotchas
  • 11. References in Four Flavors
    • 11.1. The Problem
    • 11.2. Java Reference Concepts
      • 11.2.1. Strong References
      • 11.2.2. Weak References
      • 11.2.3. Soft References
      • 11.2.4. Phantom References
      • 11.2.5. References and Referents
      • 11.2.6. Reference Queues
      • 11.2.7. The Garbage-Collection Process
    • 11.3. The Java Reference Classes
      • 11.3.1. Reference Classes
        • 11.3.1.1. java.lang.ref.Reference
        • 11.3.1.2. java.lang.ref.WeakReference
        • 11.3.1.3. java.lang.ref.SoftReference
        • 11.3.1.4. java.lang.ref.PhantomReference
      • 11.3.2. Reference Queues
    • 11.4. Practical Applications
      • 11.4.1. A Weak Collection
      • 11.4.2. Testing WeakHashSet
    • 11.5. A Weak Listener
    • 11.6. When to Use References
  • 12. Tiger: JDK 1.5
    • 12.1. New Language Features
      • 12.1.1. For Each
      • 12.1.2. Autoboxing with Variables
        • 12.1.2.1. Implicit casting
        • 12.1.2.2. Ambiguous autoboxing
      • 12.1.3. Enums
        • 12.1.3.1. Adding functionality to enums
        • 12.1.3.2. Interfaces and hierarchies
      • 12.1.4. Static Imports
      • 12.1.5. Variable Arguments
    • 12.2. Generics
      • 12.2.1. The Syntax of Generics
        • 12.2.1.1. Nested generics
        • 12.2.1.2. Multi-generics
        • 12.2.1.3. Bounds
        • 12.2.1.4. Wildcards
        • 12.2.1.5. Lower bounds
        • 12.2.1.6. Raw types
      • 12.2.2. Erasure
        • 12.2.2.1. Cracking type safety
      • 12.2.3. Casting Generics
      • 12.2.4. Generic Methods
      • 12.2.5. Inference
        • 12.2.5.1. Simple generic inference
        • 12.2.5.2. Masking methods with inference
        • 12.2.5.3. Inference based on return type
        • 12.2.5.4. Generic parameter-based inference
        • 12.2.5.5. Context-sensitive inference
        • 12.2.5.6. Avoiding inference through explicit declaration
      • 12.2.6. Generic Gotchas
        • 12.2.6.1. Going overboard
        • 12.2.6.2. Compile-time class conformance
    • 12.3. Other Improvements in Tiger
  • About the Author
  • Colophon
  • SPECIAL OFFER: Upgrade this ebook with OReilly

pokaż cały spis treści

ukryj recenzje