Meera Subbarao has a Bachelors degree in Electronics and Communication Engineering. She has seventeen years of software programming experience around the globe, from Bangalore, India to Dubai, United Arab Emirates, to the United States, where she has spent the past four years at DataSource, Inc. in Maryland. She has been working on J2EE technologies exclusively for the last four years. Her four years at DataSource have been focused on the creation of a J2EE productivity suite called “Jetson”. Version 1.1 is available for sale to the public.
The Rich Engineering Heritage Behind Dependency Injection
Andrew McVeigh takes us on a tour of the rich heritage behind dependency injection, what it represents, and tells us why its here to stay.
NetBeans 6: Matisse Updates
NetBeans 6 delivers great updates to the Matisse GUI builder. Spend a few minutes with Roman Strobl and get an expert briefing on what's new and what has changed. (sponsored)
Introduction to Groovy Part 3
In this, the third and final installation of Andres' Introduction to Groovy series, you learn about how Groovy handles variable numbers of arguments, named parameters, currying, and more about Groovy operators. Including, some new operators.
Easier Custom Components with Swing Fuse
Swing Fuse (actually just Fuse), is a framework designed to make it easier to create your own custom desktop components. In this article, Daniel Spiewak shows you how to get started and provides sample source code you can download.
Benchmark Analysis: Guice vs Spring
Willam Louth shows how he uses JXInsight Probes to investigate probable performance issues with code bases that he is not familiar with. He also highlights possible pitfalls in creating a benchmark, as well as in the analysis of results.Thinking In Java, 4th Edition
Author: Bruce Eckel
Publisher: Prentice Hall
Date of publication: February 2006
Sample Chapter: Chapter One: Introduction To Objects!
Reviewer: Meera Subbarao
Intro, what is the main purpose of this book? What is the intended audience?
Thinking in Java is a complete guide to the Java programming language. The book is very well organized, has plenty of examples and exercises for the reader to practice in each and every chapter. The most important feature about this book is that it covers Java SE5 and as the author states the code is also tested against a release candidate of Java SE6. Fairly new topics like Generics, Concurrency and Annotations are covered so well that it gives the reader fundamental to deep knowledge of each concept.
Summary of TOC/Sections
The first 3 chapters cover the basics of Java as well as object-oriented programming. The author brings in the concept of an object very well and also how to think like a Java programmer. The next few chapters are about Operators and Controlling Execution (you can skip these chapters if you are coming from a C/C++ background).
The next 2 chapters are about Initialization & Cleanup and Access Control where the readers get an in-depth knowledge about Constructors, garbage collection in Java; there are plenty of examples for various types of initialization. The chapter on Access Control is very important and the readers should not skip this chapter if they are going to be a Java programmer.
The next 4 chapters will make the reader more comfortable about the OOP’s concepts. These chapters are Reusing Classes, Polymorphism, Interfaces and Inner Classes. The concepts become very clear with the help of extensive and to the point examples. Rather than teaching object-oriented programming at an academic level, these chapters have examples and exercises which help the readers to apply the concepts the right way. The author has done an excellent job in explaining how object-oriented programming also opens the prospect of more flexible software that is able to respond dynamically to the needs of the application at runtime.
Java provides a number of ways to hold objects, and in this chapter Holding your Objects the author covers the all the types with plenty of examples and exercises after each type. Exception handling is not optional in Java and a programmer has to know when and how to use exception handling in a beneficial way and this is the focus of this chapter Error handling with Exceptions.
The next 2 chapters are about Strings and Type Information. In the Strings chapter the user gets an idea of String manipulation, operations on String, regular expressions, formatting output and again with ample examples. In Type Information chapter which I think is very important to any programmer explains how to use runtime class information in Java programs, the class objects, casting, reflection and also dynamic proxies.
Generics one of the more significant changes in SE5 is a very useful chapter which definitely should be read from start to finish. The author covers a good deal of topics including the limitations of Java generics. It is uncomplicated to use a generic library but it requires a great deal of proficiency to explain and the author has done a wonderful job in this chapter also.
Arrays are again covered in the next chapter, where the reader gets to learn how to use Multi dimensional arrays, Arrays and Generics, Arrays utilities, Data generators with plenty of examples.
Containers in Depth explains in detail about the container library which is the most important for any object-oriented language. This chapter also explains how to write your own hashCode() implementation. I/O chapter covers a variety of I/O classes in the java.io library and explains how to use them.
The next few chapters cover the new features in SE5 like the Enumerated Types is really well explained with numerous examples. Annotations also a new feature for SE5, the author explains how to create you own annotations. Concurrency was the most interesting topic for me in this book, even though this chapter was almost 190 pages; each and every page is worth reading. Kudos to the author on this wonderful and very interesting chapter.
Graphical User Interfaces gives a good introduction to designing the GUI, but as the author mentions there are a couple of good books for the same. This chapter will help the readers as a good starter kit for using other UI design toolkits.
Conclusion
In spite of the huge volume of this book (I am not complaining), of course you need these many pages to explain as thoroughly as the Author has; it keeps the readers interest until the end. Being a programmer myself for slightly less than 2 decades, I wish I had this book when I started programming. I recommend this book to every student as well as beginner and intermediate Java programmer. This book would also serve as a guide to those who would wish to write the Sun Certified Java Programmer (SCJP) certification exam. It also introduces design patterns and testing which is really good since we see programmers writing 100’s of lines of code with no design pattern being used or a single test case being written often. Get this book and become a better Java programmer.
Check out Thinking in Java on Prentice Hall's website.
