Hardcore Java 1st Edition by Robert Simmons ISBN 9780596005689

 Hardcore Java 1st Edition by Robert Simmons – Ebook PDF Instant Download/Delivery. 9780596005689
Full download  Hardcore Java 1st Edition after payment

Product details:

ISBN 10: 
ISBN 13: 9780596005689
Author: Robert Simmons

Java has quickly become one of the most important languages in programming, particularly for professional and enterprise-level projects. From its infancy as a language primarily used for web applets to its maturity through servlets, Enterprise JavaBeans, and database access, Java has become a complex and robust tool for today’s developer.Hardcore Java takes this language and breaks it apart, piece by piece, revealing the important secrets and tricks that will take you from a junior-level programmer to a seasoned and expert developer. You’ll fly through the fundamentals and quickly find yourself learning about advanced memory management techniques, optimization and bytecode-level enhancements, and the techniques required to build lightning-fast GUIs. Throughout the book, you’ll also master the art of writing and maintaining bulletproof and error-proof code, all while grasping the intricacies of the Java language.Hardcore Java covers:

• Use of the final keyword to optimize and protect your Java classes.
• Complete and thorough coverage of all types of nested classes, including how to optimize anonymous and inner classes.
• Detailed discussion of immutable objects, including unique tips on when to use them (and when not to).
• Elimination of bugs through exception-handling management.
• In-depth studies of constants, including their impact on the Java memory model.
• The most thorough discussion of reflection in print, moving far beyond other books’ “Hello World” coverage.
• Construction and use of dynamic proxies, in both Java Standard and Enterprise editions.
• Expansive coverage of weak references, including usage patterns and their role in garbage collection and memory management.

Hardcore Java is an invaluable addition to every programmer’s library, and even the most advanced developers will find themselves moving beyond their own conceptions into truly advanced applications of the language. Thousands of lines of code, heavily commented and easily runnable, illustrate each concept in the book.

  Hardcore Java 1st Table of contents:

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

People also search for  Hardcore Java 1st:

Java Programming
Advanced Java
Object-Oriented Programming
Java SE (Standard Edition)
Concurrency in Java