Customer Reviews

Java Pocket Guide (Pocket Guides)

5 star:		(3)
4 star:		(2)
3 star:		(2)
2 star:		(2)
1 star:		(0)

 

 

This short and sweet pocket-sized Java guide covers the subject quickly and to the point. It brings together the main Java concepts in a single, compact format. Sometimes it's nice to have a feather-light reference in your rucksack.

While tiny, the guide contains the following:

Part I. Language
Chapter 1: Naming Conventions
Chapter 2: Lexical Elements
Chapter 3: Fundamental Types
Chapter 4: Reference Types
Chapter 5: Object-Oriented Programming
Chapter 6: Statements and Blocks
Chapter 7: Exception Handling
Chapter 8: Java Modifiers

Part II. Platform
Chapter 9: Java Platform, SE
Chapter 10: Development Basics
Chapter 11: Basic Input and Output
Chapter 12: Java Collections Framework
Chapter 13: Generics Framework
Chapter 14: Concurrency
Chapter 15: Memory Management
Chapter 16: The Java Scripting API
Chapter 17: Third-Party Tools
Chapter 18: UML Basics

The book is well organized and well written. It contains micro-snippets of code for virtually every topic covered. It's a helpful book to keep around for review or quick lookups. If you are new to Java but already a programmer of another object-oriented language, you could read it to get a quick, high-level overview. I have found it to be among the most useful Java books I own.

This is a model for all reference books in my mind. Clearly written and to the point. There are sections covering all the main aspects of the language. It is well worth getting for any/all Java developers. Even though I know Java, I have been referring to it when I travel.

An easy purchase.

I don't know about you, but when I'm confused about something, I'm really confused. I need an example to clear up my confusion or my memory. This book gives examples in the most superficial of terms. It is designed to be a quick guide to J2SE through the Java 6 Platform, and quick is what it is. It is not going to jump start you if you need a real jump start on an issue you have forgotten. The most useful information is at the very end of the guide where it talks about the Java Scripting API, tools, and UML. The first half of the book is oriented towards the Java programming language and the second half is about the platform components and some special topics.

If you need useful examples in an accessible format I still suggest the Core Java books by Cornell. They may be somewhat unwieldy to lug around on trips, but they get the job done. Java Examples in a Nutshell is somewhat outdated, but it still can clear up some questions on parts of the language that haven't changed over the years. If you are new to Java I absolutely recommend against getting this pocket guide. You'll be lost. I include the table of contents since it is currently not listed in the product description.

Chapter 1. Naming Conventions
Section 1.1. Class Names
Section 1.2. Interface Names
Section 1.3. Method Names
Section 1.4. Instance and Static Variable Names
Section 1.5. Parameter and Local Variables Names
Section 1.6. Generic Type Parameter Names
Section 1.7. Constant Names
Section 1.8. Enumeration Names
Section 1.9. Package Names
Section 1.10. Acronyms
Chapter 2. Lexical Elements
Section 2.1. Unicode and ASCII
Section 2.2. Comments
Section 2.3. Keywords
Section 2.4. Identifiers
Section 2.5. Separators
Section 2.6. Operators
Section 2.7. Literals
Section 2.8. Escape Sequences
Section 2.9. Unicode Currency Symbols
Chapter 3. Fundamental Types
Section 3.1. Primitive Types
Section 3.2. Literals for Primitive Types
Section 3.3. Floating-Point Entities
Section 3.4. Numeric Promotion of Primitive Types
Section 3.5. Wrapper Classes
Section 3.6. Autoboxing and Unboxing
Chapter 4. Reference Types
Section 4.1. Comparing Reference Types to Primitive Types
Section 4.2. Default Values
Section 4.3. Conversion of Reference Types
Section 4.4. Converting Between Primitives and Reference Types
Section 4.5. Passing Reference Types into Methods
Section 4.6. Comparing Reference Types
Section 4.7. Copying Reference Types
Section 4.8. Memory Allocation and Garbage Collection of Reference Types
Chapter 5. Object-Oriented Programming
Section 5.1. Classes and Objects
Section 5.2. Variable Length Argument Lists
Section 5.3. Abstract Classes and Abstract Methods
Section 5.4. Static Data Members, Static Methods, and Static Constants
Section 5.5. Interfaces
Section 5.6. Enumerations
Section 5.7. Annotations Types
Chapter 6. Statements and Blocks
Section 6.1. Expression Statements
Section 6.2. Empty Statement
Section 6.3. Blocks
Section 6.4. Conditional Statements
Section 6.5. Iteration Statements
Section 6.6. Transfer of Control
Section 6.7. Synchronized Statement
Section 6.8. Assert Statement
Section 6.9. Exception Handling Statements
Chapter 7. Exception Handling
Section 7.1. The Exception Hierarchy
Section 7.2. Checked/Unchecked Exceptions and Errors
Section 7.3. Common Checked/Unchecked Exceptions and Errors
Section 7.4. Exception Handling Keywords
Section 7.5. The Exception Handling Process
Section 7.6. Defining Your Own Exception Class
Section 7.7. Printing Information About Exceptions
Chapter 8. Java Modifiers
Section 8.1. Access Modifiers
Section 8.2. Other (Non-Access) Modifiers
Chapter 9. Java Platform, SE
Section 9.1. Common Java SE API Libraries
Chapter 10. Development Basics
Section 10.1. Java Runtime Environment
Section 10.2. Java Development Kit
Section 10.3. Java Program Structure
Section 10.4. Command-Line Tools
Section 10.5. Classpath
Chapter 11. Basic Input and Output
Section 11.1. Standard Streams in, out, and err
Section 11.2. Class Hierarchy for Basic Input and Output
Section 11.3. File Reading and Writing
Section 11.4. Socket Reading and Writing
Section 11.5. Serialization
Section 11.6. Zipping and Unzipping Files
Section 11.7. File and Directory Handling
Chapter 12. Java Collections Framework
Section 12.1. The Collection Interface
Section 12.2. Implementations
Section 12.3. Collection Framework Methods
Section 12.4. Collections Class Algorithms
Section 12.5. Algorithm Efficiencies
Section 12.6. Comparator Interface
Chapter 13. Generics Framework
Section 13.1. Generic Classes and Interfaces
Section 13.2. Constructors with Generics
Section 13.3. Substitution Principle
Section 13.4. Type Parameters, Wildcards, and Bounds
Section 13.5. The Get and Put Principle
Section 13.6. Generic Specialization
Section 13.7. Generic Methods in Raw Types
Chapter 14. Concurrency
Section 14.1. Creating Threads
Section 14.2. Thread States
Section 14.3. Thread Priorities
Section 14.4. Common Methods
Section 14.5. Synchronization
Section 14.6. Concurrent Utilities
Chapter 15. Memory Management
Section 15.1. Garbage Collectors
Section 15.2. Memory Management Tools
Section 15.3. Command-Line Options
Section 15.4. Resizing the JVM Heap
Section 15.5. Interfacing with the GC
Chapter 16. The Java Scripting API
Section 16.1. Scripting Languages
Section 16.2. Script Engine Implementations
Section 16.3. Setting Up Scripting Languages and Engines
Chapter 17. Third-Party Tools
Section 17.1. Development Tools
Section 17.2. Libraries
Section 17.3. IDEs
Section 17.4. Web Application Platforms
Section 17.5. Scripting Languages
Chapter 18. UML Basics
Section 18.1. Class Diagrams
Section 18.2. Object Diagrams
Section 18.3. Graphical Icon Representation
Section 18.4. Connectors
Section 18.5. Multiplicity Indicators
Section 18.6. Role Names
Section 18.7. Class Relationships
Section 18.8. Sequence Diagrams

This book is a concise reference to the Java language, in the same format and style as the rest of the O'Reilly "Pocket Guides".

However - this one has errors. There is some bad editing where the same thing is described two different ways in sequential paragraphs - the two paragraphs being slightly different in meaning. One should have been cleaned up during editing, but wasn't. There are some points where the wording is misleading or incomplete, but you can guess what it should be. And some points where the book is just wrong.

Here's one example: On page 64 on handling exceptions it says the order of the catch clauses in a try statement is important because it determines which catch clause handles the exception. And it says therefore, put the most specific clauses first. This is correct. Then there is a TIP which says exceptions are directed to the first catch clause containing "arguments of the same type as the exception object or superclass of that type". This is also correct. Then the very next sentence (top of page 65) says: "If none of the parameters for the catch clauses match the exception thrown, the system will search for the parameter that matches the superclass of the exception." This is wrong, and also contradicts the previous correct sentences.

As far as omissions are concerned, the words "inner", "anonymous", and "initializer" do not occur in the book or in the index. And that's just what I've noticed: there may be more missing that I didn't notice. The discussion of access modifiers is extremely terse and contains only a circular definition of package-private.

Keep your mind working when reading this book, or you may be misled. One nice thing about this book, like all the O'Reilly Pocket Guides, is its small physical size. It is easy to carry around. If you want a more accurate concise Java reference, in a larger size, consider Java Precisely, 2nd Edition (however it doesn't cover as much of the Java Platform - check the table of contents).

The idea of the book is OK, but I personally agree with another review that the focus could have been on other material to truly be useful as a pocket guide. Most of the material could be in a beginning Java book that you simply read once and leave on the shelf. For me I was hoping for a pocket sized book with the following:
1) Those reference items that I will never remember, but need every couple of months (Java primitive ranges, for example)
2) Clean and correct cookbook style code listings of common programming examples without alot of explanation text (Loading an xml file and parsing it, for example)
3) Very concise explanations or tables of Java programming concepts that I know, but need to have my memory jogged a bit about when I actually use them (List of Collection types and when each is appropriate in the real world, for example)
4) A few very short best practices tips (Paragraph versions of the most important Items in "Effective Java", for example)

The part of the book I liked sort of has each of these, but it could be much better. Another problem I had with it is that it has quite a few minor errors in the text, code samples and formatting.

This pocket reference covers nearly all of the Java language and some of the most commonly used parts of the standard library, provides command line references of the JDK utilities, lists many popular third-party tools, and explains the basics of UML. There are some Java language features omitted, for example, static and instance initializers and anonymous classes. Many basic operations provided by the library, such as math and formatted output, are not covered. Instead of covering each basic operation, however, the book concentrates on giving an overview of such features as the collections classes, concurrency, and I/O. With this overview, the reader can look up the specifics in the online API documentation.

This is a handy pocket reference/guide for the intermediate or advanced programmer. All materials are well-organized and illustrated with concise examples of code. It is "worth it's weight" and should be on every Java programmer's reference bookshelf.

This is readable, concise guide for Java.
Since Java is huge, one have to carefully choose the material for such small book.
In my opinion, the focus should be on:

1. Collections.
2. Threads.
3. IO
4. Reflections.

I gave this guide a 3 starts because it did not cover enough in those areas.

This book was used for a college course as a reference book. Served it's purpose and came in handy. Good buy.