java left logo
java middle logo
java right logo
 

Home arrow Book Reviews arrow Thinking in Java - Third Edition
 
 
Main Menu
Home
Java Tutorials
Book Reviews
Java SE Tips
Java ME Tips
Java EE Tips
Other API Tips
Java Applications
Java Libraries
Java Games
Java Network
Java Forums
Java Blog




Most Visited Tips
Java SE Tips
Java ME Tips
Java EE Tips
Other API Tips
Java Applications
Java Libraries
Java Games
Book Reviews
Top Rated Tips
Java SE Tips
Java ME Tips
Java EE Tips
Other API Tips
Java Applications
Java Libraries
Java Games
Book Reviews


Statistics
Registered Users: 4090
Java SE Tips: 614
Java ME Tips: 202
Java EE Tips: 183
Other API Tips: 779
Java Applications: 298
Java Libraries: 209
Java Games: 16
Book Reviews:
 
 
 
Thinking in Java - Third Edition E-mail
User Rating: / 46
PoorBest 
 Book Information

Image

Authors: Bruce Eckel
Paperback: 1119 pages
Publisher: Prentice Hall PTR; 3 edition (December 6, 2002)
Language: English
ISBN: 0131002872
Product Dimensions: 9.3 x 7.0 x 1.6 inches
ImageAmazon.com Link


 Book Review

Thinking in Java by Bruce Eckel is a complete guide to the Java programming language as it strikes a proper balance between an introduction geared towards new users, and also going into enough depth so as to enable the programmers to accomplish relatively sophisticated tasks. The book gives the readers a practical mastery over most of the important Java 2 features and capabilities enabling them to build more powerful, robust, and reliable software systems.

This book covers all the essential Java features and techniques which programmers are likely to need. It covers various topics right from Object Oriented Programming concepts to inheritance, Polymorphism, interfaces, Error handling etc. Apart from focusing on the Java I/O system issues related to Concurrency and Applets had also been explained in the best of possible ways.

The author starts the book with an introduction to objects wherein issues related to OOP and Java had been discussed. How base class presents only an interface for its derived classes, how objects are created, their use and lifetime related issues had been extensively covered. Next the author moves on to building of a Java program considering various aspects like name visibility, static keyword etc.

The book also deals with certain Program Flow control features of Java. It mainly speaks of different Java operators, their usage, their evaluation using operators’ precedence and various Java’s execution control statements. The author had also taken into account the Initialization & Cleanup features including initialization using constructor, method overloading concept and working of garbage collector.

The information related to Implementation Hiding and Reusing is of great use to the developers. Taking the Implementation Hiding topic further the author also discusses various access control levels along with creation of unique package names, the Java access specifiers and separation of interface from the implementation. Reusing issue mainly includes discussion regarding the composition and inheritance concept. The book also takes up the Polymorphism aspect of Java in an effective way.

Besides the basic navigation of various Java features, this title delivers plenty of useful advanced material for extending Java’s capabilities. Multiple inheritance, Inner Classes as well as Error Handling techniques had also been mentioned. Much had been said regarding the exception handling, generation of own exceptions as well as cleanup functionality using finally. The book gives an in depth-coverage of the run-time type identification (RTTI) aspect of Java.

Author had provided sufficient experience in designing and implementing Java containers including Map, List and Set interface. From here the author jumps to the Java I/O system where various I/O classes, types of Input and Output Streams, reading from InputStream and OutputStream as well as some Concurrency concept had been explained. The remaining part of the book covers the creation of Windows and Applets along with some analysis and design concepts.

Thinking in Java goes much further in explaining the keys issues of Java Programming language. Each chapter of this book takes the reader to a new joy ride of some or the other interesting topic. Its easy readability and simple language proves to be an added advantage for the programmers. Moreover the wealth of experience of the author is reflected throughout the book thereby making it a good resource for Java programmers.


 Table of Contents
  1. Chapter 1: Introduction to Objects

    • The progress of abstraction
    • An object has an interface
    • An object provides services
    • The hidden implementation
    • Reusing the implementation
    • Inheritance: reusing the interface
    • Is-a vs. is-like-a relationships
    • Interchangeable objects with polymorphism
    • Abstract base classes and interfaces
    • Object creation, use &lifetimes
    • Collections and iterators
    • The singly rooted hierarchy
    • Down casting vs. templates/generics
    • Ensuring proper cleanup
    • Exception handling: dealing with errors
    • Concurrency
    • Persistence
    • Java and the Internet
    • What is the Web
    • Client-side programming
    • Server-side programming
    • Applications
    • Why Java succeeds
    • Systems are easier to express and understand
    • Maximal leverage with libraries
    • Error handling
    • Programming in the large
    • Java vs. C++?
    • Summary

  2. Chapter 2: Everything is an Object

    • You manipulate objects with references
    • You must create all the objects
    • Where storage lives
    • Special case: primitive types
    • Arrays in Java
    • You never need to destroy an object
    • Scoping
    • Scope of objects
    • Creating new data types: class
    • Fields and methods
    • Methods, arguments, and return values
    • The argument list
    • Building a Java program
    • Name visibility
    • Using other components
    • The static keyword.
    • Your first Java program
    • Compiling and running
    • Comments and embedded documentation
    • Comment documentation
    • Syntax
    • Embedded HTML
    • Some example tags
    • Documentation example
    • Coding style
    • Summary
    • Exercises

  3. Chapter 3: Controlling Program Flow

    • Using Java operators
    • Precedence
    • Assignment
    • Mathematical operators
    • Auto increment and decrement
    • Relational operators
    • Logical operators
    • Bitwise operators
    • Shift operators
    • Ternary if-else operator
    • The comma operator
    • String operator +
    • Common pitfalls when using operators
    • Casting operators
    • Java has no “sizeof”
    • Precedence revisited
    • A compendium of operators
    • Execution control
    • true and false
    • if-else
    • return
    • Iteration
    • do-while
    • for
    • break and continue
    • switch
    • Summary
    • Exercises

  4. Chapter 4: Initialization & Cleanup

    • Guaranteed initialization with the constructor
    • Method overloading
    • Distinguishing overloaded methods
    • Overloading with primitives
    • Overloading on return values
    • Default constructors
    • The this keyword
    • Cleanup: finalization and garbage collection
    • What is finalize( ) for?
    • You must perform cleanup
    • The termination condition
    • How a garbage collector works
    • Member initialization
    • Specifying initialization
    • Constructor initialization
    • Array initialization
    • Multidimensional arrays
    • Summary
    • Exercises

  5. Chapter 5: Hiding the Implementation

    • Package: the library unit
    • Creating unique package names
    • A custom tool library
    • Using imports to change behavior
    • Package caveat
    • Java access specifiers
    • Package access
    • public: interface access
    • private: you can’t touch that!
    • protected: inheritance access
    • Interface and implementation
    • Class access
    • Summary
    • Exercises

  6. Chapter 6: Reusing Classes

    • Composition syntax
    • Inheritance syntax
    • Initializing the base class
    • Combining composition and inheritance
    • Guaranteeing proper cleanup
    • Name hiding
    • Choosing composition vs. inheritance
    • protected
    • Incremental development
    • Upcasting
    • Why “upcasting
    • The final keyword
    • Final data
    • Final methods
    • Final classes
    • Final caution
    • Initialization and class loading
    • Initialization with inheritance
    • Summary
    • Exercises

  7. Chapter 7: Polymorphism

    • Upcasting revisited
    • Forgetting the object type
    • The twist
    • Method-call binding
    • Producing the right behavior
    • Extensibility
    • Pitfall: “overriding” private methods
    • Abstract classes and methods
    • Constructors and polymorphism
    • Order of constructor calls
    • Inheritance and cleanup
    • Behavior of polymorphic methods inside constructors
    • Designing with inheritance
    • Pure inheritance vs. extension
    • Downcasting and run time type identification
    • Summary
    • Exercises

  8. Chapter 8: Interfaces & Inner Classes

    • Interfaces
    • “Multiple inheritance” in Java
    • Extending an interface with
    • inheritance
    • Grouping constants
    • Initializing fields in interfaces
    • Nesting interfaces
    • Inner classes
    • Inner classes and upcasting
    • Inner classes in methods and scopes
    • Anonymous inner classes
    • The link to the outer class
    • Nested classes
    • Referring to the outer class object
    • Reaching outward from a multiply nested class
    • Inheriting from inner classes
    • Can inner classes be overridden?
    • Local inner classes
    • Inner class identifiers
    • Why inner classes?
    • Closures & Callbacks
    • Inner classes & control frameworks
    • Summary
    • Exercises

  9. Chapter 9: Error Handling with Exceptions

    • Basic exceptions
    • Exception arguments
    • Catching an exception
    • The try block
    • Exception handlers
    • Creating your own exceptions
    • The exception specification
    • Catching any exception
    • Rethrowing an exception
    • Exception chaining
    • Standard Java exceptions
    • The special case of RuntimeException
    • Performing cleanup with finally
    • What’s finally for?
    • Pitfall: the lost exception
    • Exception restrictions
    • Constructors
    • Exception matching
    • Alternative approaches
    • History
    • Perspectives
    • Passing exceptions to the console
    • Converting checked to unchecked exceptions
    • Exception guidelines
    • Summary
    • Exercises

  10. Chapter 10: Detecting types

    • The need for RTTI
    • The Class object
    • Checking before a cast
    • RTTI syntax
    • Reflection: run time class information
    • A class method extractor
    • Summary
    • Exercises

  11. Chapter 11: Collections of Objects

    • Arrays
    • Arrays are first-class objects
    • Returning an array
    • The Arrays class
    • Filling an array
    • Copying an array
    • Comparing arrays
    • Array element comparisons
    • Sorting an array
    • Searching a sorted array
    • Array summary
    • Introduction to containers
    • Printing containers
    • Filling containers
    • Container disadvantage: unknown type
    • Sometimes it works anyway
    • Making a type-conscious ArrayList
    • Iterators
    • Container taxonomy
    • Collection functionality
    • List functionality
    • Making a stack from a LinkedList
    • Making a queue from a LinkedList
    • Set functionality
    • SortedSet
    • Map functionality
    • SortedMap
    • LinkedHashMap
    • Hashing and hash codes
    • Overriding hashCode( )
    • Holding references
    • The WeakHashMap
    • Iterators revisited
    • Choosing an implementation
    • Choosing between Lists
    • Choosing between Sets
    • Choosing between Maps
    • Sorting and searching Lists
    • Utilities
    • Making a Collection or Map unmodifiable
    • Synchronizing a Collection or Map
    • Unsupported operations .
    • Java 1.0/1.1 containers
    • Vector & Enumeration
    • Hashtable
    • Stack
    • BitSet
    • Summary
    • Exercises

  12. Chapter 12: The Java I/O System

    • The File class
    • A directory lister
    • Checking for and creating directories
    • Input and output
    • Types of InputStream
    • Types of OutputStream
    • Adding attributes and useful interfaces
    • Reading from an InputStream with FilterInputStream
    • Writing to an OutputStream with FilterOutputStream
    • Readers & Writers
    • Sources and sinks of data
    • Modifying stream behavior
    • Unchanged Classes
    • Off by itself: RandomAccessFile
    • Typical uses of I/O streams
    • Input streams
    • Output streams
    • Piped streams
    • Standard I/O
    • Reading from standard input
    • Changing System.out to a PrintWriter
    • Redirecting standard I/O
    • Compression
    • Simple compression with GZIP
    • Multifile storage with Zip
    • Java ARchives (JARs)
    • Object serialization
    • Finding the class
    • Controlling serialization
    • Using persistence
    • Regular expressions
    • Creating regular expressions
    • Quantifiers
    • Pattern and Matcher
    • split( )
    • Replace operations
    • reset( )
    • Capturing Groups
    • Regular expressions and Java I/O
    • Is StringTokenizer needed?
    • Summary
    • Exercises

  13. Chapter 13: Concurrency

    • Motivation
    • Basic threads
    • Yielding
    • Sleeping
    • Priority
    • Daemon threads
    • Joining a thread
    • Coding variations
    • Creating responsive user interfaces
    • Sharing limited resources
    • Improperly accessing resources
    • Colliding over resources
    • Resolving shared resource contention
    • Critical sections
    • Thread states
    • Becoming blocked
    • Cooperation between threads
    • Wait and notify
    • Using Pipes for IO between threads
    • More sophisticated cooperation.
    • Deadlock
    • The proper way to stop
    • Interrupting a blocked thread
    • Thread groups
    • Summary
    • Exercises

  14. Chapter 14: Creating Windows & Applets

    • The basic applet
    • Applet restrictions
    • Applet advantages
    • Application frameworks
    • Running applets inside a Web browser
    • Using Appletviewer
    • Testing applets
    • Running applets from the command line
    • A display framework
    • Making a button
    • Capturing an event
    • Text areas
    • Controlling layout
    • BorderLayout
    • FlowLayout
    • GridLayout
    • GridBagLayout
    • Absolute positioning
    • BoxLayout
    • The best approach
    • The Swing event model
    • Event and listener types
    • Tracking multiple events
    • A catalog of Swing components
    • Buttons
    • Icons
    • Tool tips
    • Text fields
    • Borders
    • JScrollPanes
    • A mini-editor
    • Check boxes
    • Radio buttons
    • Combo boxes (drop-down lists).
    • List boxes
    • Tabbed panes
    • Message boxes
    • Menus
    • Pop-up menus
    • Drawing
    • Dialog Boxes
    • File dialogs
    • HTML on Swing components
    • Sliders and progress bars
    • Trees
    • Tables
    • Selecting Look & Feel
    • The clipboard
    • Packaging an applet into a JAR file
    • Signing applets
    • JNLP and Java Web Start
    • Programming techniques
    • Binding events dynamically
    • Separating business logic from UI logic
    • A canonical form
    • Concurrency & Swing
    • Runnable revisited
    • Managing concurrency
    • Visual programming and Beans
    • What is a Bean?
    • Extracting BeanInfo with the Introspector
    • A more sophisticated Bean
    • JavaBean and synchronization
    • Packaging a Bean
    • More complex Bean support
    • More to Beans
    • Summary
    • Exercises

  15. Chapter 15: Discovering problems

    • Unit Testing
    • A Simple Testing Framework
    • JUnit
    • Improving reliability with assertions
    • Assertion syntax
    • Using Assertions for Design by Contract
    • Example: DBC + white-box unit testing
    • Building with Ant
    • Automate everything
    • Problems with make
    • Ant: the defacto standard
    • Version control with CVS
    • Daily builds
    • Logging
    • Logging Levels
    • LogRecords
    • Handlers
    • Filters
    • Formatters
    • Example: Sending email to report log messages
    • Controlling Logging Levels through Namespaces
    • Logging Practices for Large Projects
    • Summary
    • Debugging
    • Debugging with JDB
    • Graphical debuggers
    • Profiling and optimizing
    • Tracking memory consumption
    • Tracking CPU usage
    • Coverage testing
    • JVM Profiling Interface
    • Using HPROF
    • Thread performance
    • Optimization guidelines
    • Doclets
    • Summary
    • Exercises

  16. Chapter 16: Analysis and design

    • Methodology
    • Phase 0: Make a plan
    • The mission statement
    • Phase 1: What are we making?
    • Phase 2: How will we build it?
    • Five stages of object design
    • Guidelines for object development
    • Phase 3: Build the core
    • Phase 4: Iterate the use cases
    • Phase 5: Evolution
    • Plans pay off
    • Extreme programming
    • Write tests first
    • Pair programming
    • Strategies for transition
    • Guidelines
    • Management obstacles
    • Summary

  17. A: Passing & Returning Objects

    • Passing references around
    • Aliasing
    • Making local copies
    • Pass by value
    • Cloning objects
    • Adding cloneability to a class
    • Successful cloning
    • The effect of Object.clone( )
    • Cloning a composed object
    • A deep copy with ArrayList
    • Deep copy via serialization
    • Adding cloneability further down a hierarchy
    • Why this strange design?
    • Controlling cloneability
    • The copy constructor
    • Read-only classes
    • Creating read-only classes
    • The drawback to immutability
    • Immutable Strings
    • The String and StringBuffer classes
    • Strings are special
    • Summary
    • Exercises

  18. B: Java Programming Guidelines

    • Design
    • Implementation

  19. C: Supplements

    • Foundations for Java seminar-on-CD
    • Hands-On Java seminar-on-CD 3rd edition
    • Thinking in Java Seminar
    • Thinking in Enterprise Java
    • Designing Objects & Systems Seminar
    • Thinking in Patterns with Java
    • Thinking in Patterns Seminar
    • Design Consulting, Reviews and Walkthroughs

  20. D: Resources

    • Software
    • Books
    • Analysis & design
    • Python
    • My own list of books
    • Index
 Overview of Chapters
  1. Chapter 1: Introduction to Objects

    • Basic concepts and issues related to OOP and JAVA.
    • How you can make the base class to present only an interface for its derived classes.
    • Object creation, use and lifetimes related issues of OOP.
    • How to ensure a proper clean up of object in order to release the resources for reuse.
    • How to design a good error handling scheme.
    • The Concurrency concept.
    • The Java and internet related issues.

  2. Chapter 2: Everything is an Object

    • The class keyword.
    • How to build a Java program considering various aspects like name visibility, static keyword etc.
    • How to compile and run a Java Program.
    • How to introduce comments and other embedded documentation while programming.
    • How to document the code and maintain the documentation.

  3. Chapter 3: Controlling Program Flow

    • What are the different operators in Java.
    • How to use various Java operators.
    • How an expression evaluates when several operators are present using operators precedence.
    • Why Java does not need a sizeof() operator.
    • Java’s execution control statements.

  4. Chapter 4: Initialization & Cleanup

    • How to guarantee initialization using constructor.
    • The concept of method overloading and this keyword.
    • What is finalization () for?
    • How a garbage collector works.
    • Member and array initialization.

  5. Chapter 5: Hiding the Implementation

    • What are the various levels of access control?
    • How to create unique package names.
    • The Java access specificiers.
    • How to separate the interface from the implementation.
    • How to determine the classes within a library which are available to the users?

  6. Chapter 6: Reusing Classes

    • How you can reuse the code by creating new classes.
    • The concept of composition and inheritance.
    • How to use composition and inheritance together.
    • How to choose between composition and inheritance.
    • How to initialize the program with inheritance.

  7. Chapter 7: Polymorphism

    • What is Polymorphism?
    • The concept of Upcasting.
    • How to connect the method call to a method body using various binding techniques.
    • How constructors work in complex hierarchies and with polymorphism.
    • How to design efficiently with inheritance.
    • How you can retrieve the type information at run time.

  8. Chapter 8: Interfaces & Inner Classes

    • What is an Interface and how you can create it.
    • Multiple inheritance in Java.
    • How to place a class definition within another class definition.
    • What is the significance of inner classes?
    • The Closures & Callbacks.

  9. Chapter 9: Error Handling with Exceptions

    • How to properly handle exceptions.
    • How you can generate your own exceptions if one of your methods gets into trouble.
    • How to catch an exception using try block, exception handlers etc.
    • The Standard Java exceptions.
    • How to perform cleanup using finally.
    • How to handle cleanup in case of constructors.

  10. Chapter 10: Detecting types

    • What are the ways to discover information about objects and classes at run time.
    • What is the need for run-time type identification (RTTI).
    • How you can produce the reference to the Class object using a class literal.
    • How to check before a casting.
    • How you can discover class information at run time.

  11. Chapter 11: Collections of Objects

    • How you can perform various operations on arrays.
    • What are Java containers and what are its disadvantages.
    • How to make stack and queue from a LinkedList.
    • The Set and Map functionalities
    • How can you decide which implementation of Map, List or Set interface to use in order to use the functionality offered by that particular interface.
    • What are the different utilities in the Collections class?
    • How to use the synchronized keyword for Collection or Map.
    • The Java 1.0/1.1 containers.

  12. Chapter 12: The Java I/O System

    • How to use the various I/O classes in the standard Java library.
    • What are the various types of Input and Output Streams?
    • How to read from an InputStream with FilterInputStream.
    • How to write to an OutputStream with FilterOutputStream.
    • How and where you can use the I/O streams.
    • The concept of Compression.
    • How you can turn any object implementing the Serializable interface into sequence of bytes that can later be fully restored to regenerate the original object.
    • How to create some regular expressions which were added in JDK 1.4 but have been integral to Standard Unix utilities.

  13. Chapter 13: Concurrency

    • Need for Concurrency.
    • How you can create some basic threads.
    • How you can solve the shared resource contention problem.
    • What are the different states of a thread?
    • How you can implement handshaking between threads.

  14. Chapter 14: Creating Windows & Applets

    • How to create an applet vs. a regular application using Swing.
    • How to create programs that are both applets and applications thereby making them runnable either inside a browser or from the command line.
    • How to control the layout and what are the various layout managers.
    • What are the various Swing components, their usage as well as features?
    • What are the different issues worth noting when working with threads under Swing?

  15. Chapter 15: Discovering problems

    • What are the different tools to solve the problems that the compiler doesn’t look into.
    • How assertion mechanism aids in the verification of code at run time.
    • How the logging API track down problems in a program that runs, but doesn’t run right.
    • What and how you can use the information from a debugger to aid you in the discovery of subtle problems.
    • The concept of profiling.
    • How you can discover the bottlenecks that cause your program to run too slowly.

  16. Chapter 16: Analysis and design

    • An introduction to the idea of analysis, and design.
    • How to decide on design that describes what the classes look like and how they will interact.
    • What are the ways to approach the problems of developing good object-oriented programs in a reasonable amount of time?
    • The concept of Extreme Programming (XP).
    • What are the various guidelines to be considered when making the transition to OOP and Java

Reviewer: Sumit Kulshreshtha


 Related Tips

 
< Prev

Page 1 of 0 ( 0 comments )

You can share your information about this topic using the form below!

Please do not post your questions with this form! Thanks.


Name (required)


E-Mail (required)

Your email will not be displayed on the site - only to our administrator
Homepage(optional)



Comment Enable HTML code : Yes No



 
       
         
     
 
 
 
   
 
 
java bottom left
java bottom middle
java bottom right
RSS 0.91 FeedRSS 1.0 FeedRSS 2.0 FeedATOM FeedOPML Feed

Home - About Us - Privacy Policy
Copyright 2005 - 2008 www.java-tips.org
Java is a trademark of Sun Microsystems, Inc.