Regular expressions come up in many popular editors, search engines, and parsers. Knowing regular expressions can make your favorite tool even more of a favorite. Knowing them as a programmer can also make you a more productive programmer. Instead of writing your own parser, simply use a regular expression with your favorite programming language such as PERL, PHP, Java, Python, etc.

This book is a very handy guide to get you up and running quickly with regular expressions. It's not comprehensive but it's likely to tell you just what you need to know 90% of the time. It quickly, concisely covers the basics: pattern matching for single, multiple, or sets of characters, repeats, certain types of characters such as digits, the nth occurrence, and nesting. The book has examples of everything it covers with a thoughtful analysis.

As a surprise bonus, this book comes with two appendices. It tells you how to use regular expressions in popular tools and languages such as grep, MySQL, and Java. It also gives the pattern matches for common items such as zip codes, phone numbers, IP addresses, e-mails, comments, and credit card numbers. I recommend this book to anyone who ever needs to find a string quickly out of a bunch of text.

I have web application books that cover MySQL from a developer point of view. It's enough to get my database running. However, it's not enough if I want to do any optimization for performance. The book High Performance MySQL is not for developers. But if you [also] play the role of system administrator or database administrator, then this book will give you the nitty gritty of configuring MySQL for optimal performance.

The book covers MySQL commands you can execute to get all the details of your table set-up and database performance configuration. It also covers the different types of tables you can choose and the advantages of each type. It describes indexing and why it's an important consideration. Finally, the book has chapters on load balancing, replication, and security. From this book, you'll realize that it is not lack of performance on MySQL part that your database runs slow but instead lack of diligence on your part for not fine-tuning your configuration properly according to careful benchmarking analysis.

I would recommend this book to those who need to administer MySQL databases. The book does promise a second edition for MySQL 5.0 which should be quite useful since 5.0 will introduce even more choices for table types, transactions, and indicing.

Chapter 1 starts with an overview of some surprising topics. As you would expect, system environment and installation of the game demos used in the book is outlined step by step. Then a brief tutorial on using Ant and the build file provided with the game demo examples used in the book. If you download the source code for the book, you get a generous 150 classes. Many of these are utility classes that you'll find conveniently reusable in all types of game development.

Then comes the surprising part. The chapter discusses copyright law and licensing. If you are developing games for distribution, you need to know these issues. It was thoughtful of the author to share his knowledge. The author then shares some sources for obtaining graphics and audio files for use in your games.

The author's writing style is easy to read. He neither condescends to your level or talks over your head as in some books when they claim to be for the advanced programmer. The author isn't an ivory tower type that talks in the abstract (a danger since he taught a University course on it). He gets down to the practical! I found his style so enjoyable and down-to-earth that I would always read further in the book than intended in one sitting.

Chapter 2 covers frameworks. How do you want your game to run? The author gives you the flexibility of running as an applet, from Java Web Start, or an executable Jar -- all from one source code set. The chapter shows how to use the HTMLConverter tool to "magically" change your html applet code into plug-in code that gets a later version of Java if needed. Since you will probably want Java 1.4 to run your games, this is important to do since most browsers don't yet support Java 1.4 and thus need the download.

Chapter 3 is the beginning of several chapters on animation. This is where the fun starts. You'll learn techniques for faster screen repainting, smooth animation (versus jerky), and effective use of frame rates. The game demo code lets you try out the effects of your performance enhancements.

Later chapters in the book cover game architecture, game algorithms, game data persistence, etc.

In summary, this book excellently covers what a game developer needs to know to get started developing games for distribution via the web or through jars. The book describes games that can be singly played on a desktop or multiply played via the web. This book is a must read for any serious game developer. Its content is right up to date as it is based on the latest Java 1.4 API. Applet developers who don't write games will also learn some good tips for deployment, animation, and http connections.

I love the "In a Nutshell" books because they are concise. If you are like me and know lots of languages, you don't need books that teach you programming. You just need a book that teaches you the language fundamentals. That's the Nutshell style. But the style doesn't include many examples, as presumably you are experienced enough to grasp the concept and run with it. Sometimes it would be nice to have examples, though. That's what this book gives you. It has hundreds of examples. The examples are done in the Nutshell style with concise but descriptive narrative. The code includes lots of good comments. So it is easy to understand what the example is doing by reading through the code. It's a companion book so it won't teach you the concept. For example, the examples on threads will show you how to create threads but won't tell you much about what threads are or their sibling Runnable instances.

The book's examples cover core Java topics such as I/O, threads, and networking. It also covers server side Java topics such as XML, servlets, and RMI. It even covers desktop Java topics such as GUIs, printing, and graphics. Then it covers other familiar topics such as JavaBeans, applets, and internationalization.

The book's I/O examples are simple enough to understand the basics of I/O. They are useful programs that a new Java programmer would be faced with writing herself and wondering how? The thread examples includes a deadlock situation which is something to be avoided but nice to see code that causes it. The author has reached a nice compromise between making the examples simple enough to understand the underlying concepts but not so simple as to make the examples trivial. The examples have real-world applicability.

In conclusion, the book has a satisfying number of examples that can be followed by experienced programmers whether they are brand new to Java or have been coding in Java for a year or so. You will not learn Java from this book but you will improve your Java with this book. It's a nice companion to the Java In a Nutshell series.

The first thing I noticed about this pocket guide was that it was twice as thick as any other pocket guide that I own. If you have a Linux book, you'll understand why it needs to be. There's a lot to cover! My *nix books are heavy tomes. So I was thrilled to find a pocket guide for those quick look-ups that I need several times a day. This books covers the commands. The book starts with a useful overview of common directory structures. It describes file protections. Then it looks at the shell. It provides handy keyboard shortcuts.

The commands are grouped into sections such as basic file, directory, editting, etc. Its text manipulation section covers greg, egrep, and fgrep, along with many other useful commands such as sort.

This book tells you how to login, logout, shutdown. It covers network connections for ssh, telnet, scp, sftp, and ftp. It even has a small section on programming shell scripts.

Sections highlight web tasks such as browsing, e-mail, usenet news, and instant messaging.

In conclusion, the book packs a powerful punch for only 10 bucks. If you use the Linux command line, you need this book. It's quick reference style will save you a lot of time.

The cookbook style is a collection of "recipes" for solving commonly encountered problems. Java Servlet & JSP Cookbook contains about 225 recipes for servlet programming and JSPs. Since Java servlet programming and JSPs have matured over multiple years, I expected most of the recipes to be oriented towards the intermediate to advanced server side programmer. However, that is not the case. Instead, the recipes are oriented to beginners. Of course, browsing the various Java forums on the internet will uncover that there are lots of beginners just getting started in Java. These beginners are asking very basic questions on the forums. This book is the answer for them!

The book starts with the basics of how to write and deploy servlets and JSPs. A person would, of course, need to have some other knowledge of this subject. You cannot learn this topic and all its subtleties just by looking at a few recipes. The problem description of these basic recipes is too concise for a beginner to understand how the recipe might be useful to him/her. Instead, they would need to read the discussion. Sometimes the discussion seems to be "over" a beginner's level of knowledge. For example, I see lots of questions on forums about the different ways to include or forward. With so many choices, this area seems to confuse beginners. Chapter 6 covers dynamic inclusion in 8 different recipes but does not cover forward. The recipes are good and thorough. But their description would not steer the beginner to the one that is exactly what he needs. An intermediate or advanced programmer would be able to decipher the explanations. I especially liked the recipe on how to dynamically specify the file to be included within another JSP file.

Intermediate recipes include how to upload a single file or multiple files. These recipes borrow from Jason Hunter's servlet library. There are also useful recipes for sending e-mail and reading e-mail. There is a helpful chapter on how to use JavaScript with either servlets or JSPs. Other recipes include how to use multimedia in a JSP. You'll discover techniques to combine Flash with your JSP, include a QuickTime movie, or to play a soundtrack.

Advanced chapters cover internationalization, using JNDI and EJBs, and writing web parsers. The book concludes with chapters on using the Google and Amazon API.

I was disappointed the book didn't have recipes for Servlet 2.4 and JSP 2.0. These new specifications open up a brand new way of programming with JavaServer Pages. A few recipes covering tag files would have been especially helpful to those coming to Java from other internet languages. Tag files are briefly covered in the chapter on how to use tag libraries. However, this chapter is more of a how to than any useful real problem with a real solution.

The book doesn't have source code available on O'Reilly's site. This is not really a problem since most of the recipes are short and the code can be typed in quickly. Still it would have been a nice convenience to avoid the typing. Perhaps O'Reilly will add the code later to the site. Or perhaps they think it wouldn't be useful since a programmer would need to develop an entire program around a recipe for "real-world" use.

In conclusion, the book might have been a little too comprehensive. The book doesn't try to assume too much and includes some beginner recipes that I wonder are truly useful. The book seems a little schizophrenic in its identity. Some chapters read more like a how to than a real world problem/solution. Beginners and intermediate level server side Java programmers are likely to find recipes to tell them just how to solve a particular problem. Advanced programmers should carefully study the book's Table of Contents to see if they will also benefit.

I used this book as part of my study for the IBM Certification for XML Technologies. This books makes no presumptions. It is good for beginners who know nothing coming in to XML. It is also good for managers who want a high level view of developing with XML. If you do develop with XML, you will need additional books (XML in a Nutshell is good). This book does not go into detail about using the APIs for XML. It covers XSLT at a high level but you will need more detail to develop with XSL (there is a Learning XSL book available). The book covers CSS and XSL-FO particularly well. It covers all the XML syntax in an easy to remember format and graphic. The coverage on DTDs and schemas was surprisingly light. However, the part on using entity references within them was explained well.

This book is good for enterprise architects, data architects, and database administrators. It has very good introductory chapters to the topic of database design. It gives a complete example of normalization from none to 5th normal form. Most other books only talk about the 5 levels of normalization but don't give an example. The book then moves into the guts -- persistence models. It covers JDO, EJB CMP (1.0 and 2.0), EJB BMP, JDO, Hibernate, custom, JDBC, and various combinations of these. It surprised me that the book was negative towards Hibernate since Hibernate is so popular now. It was against it because Hibernate is not a standard. The book was favorable towards JDO (in the right environment) since JDO is a standard.

The third part of the book seemed a little out of place in a Best Practices book. It was a tutorial. Since the target audience of the book is mainly architects, I'm not sure they really needed a tutorial. They would either already know how to use the technologies or not care about the specifics.

Even if all you did was go through and read the boxed "Best Practice" tips, you would get your money's worth from this book. They are good practices that every architect should abide.

I love pocket guides! They are such handy references for a quick look-up. This guide has everything you need to know about doing a search on Google. It also covers the other Google pages for Directory, Images, Groups, News, and Catalogs. The appendix is the complete syntax which is extremely useful when you don't perform a particular type of search often enough to remember the syntax. If you do a lot of searching and need to improve your search results, this book will tell you how!

This book covers patterns in various tier architectures, databases, messaging, and even antipatterns. The book presents the patterns in the context of their use. So instead of learning a pattern but not knowing where to properly use it, you know immediately the usefulness of the pattern. The book has an overview of UML so you will know how to read the design pattern when it is presented later in UML. The book's format is to explain a pattern and why it is needed, to give the pattern use in a UML diagram, then to show code for implementing the pattern. The book is comprehensive. If you are doing J2EE development, you'll find the patterns you need here with enough concrete examples to actually use the pattern in your own development. The book has a handy appendix to allow you to quickly look-up a pattern's use and its UML diagram.

The book's subtitle is "Passing the Sun Certified Business Component Developer Exam". Since I haven't taken the exam or prepped for it, I'm not qualified to speak on whether this book would really help you to pass the exam. What I can comment on is the style of the book and the breadth of its coverage. The book takes a dry subject and livens it up with "eye candy", which includes "handwritten" notes, puzzles, graphics, drawings, cartoons, and diagrams. Most of the time you are not reading text but pictures! This format holds your attention longer than narrative and aids in recall of what you've "read".

This book covers all the different types of beans used in EJB development. It also covers JNDI, remote vs. local, and home interfaces and objects. It even covers EJB-QL.

I recommend you make this book your first introduction to EJBs. Then move on to a more advanced book that will have a complete EJB application. The graphics in Head First EJB will help you "picture" what is going on from the client perspective, the server perspective, and within the container. Knowing this is crucial to understanding EJB development. The pictures in the architectural overview section are particularly worthy.

Another section that will give your EJB developer life an easy start is the section on a bean's environment. This section covers the deployment descriptor. Even if most of us use XDoclet to generate the DD, it is still nice to be able to read the DD and understand what it is telling us.

After you've programmed EJBs for a while, I recommend you return to this book for your study for the Business Component Developer certification. The book takes the "Sun speak" for the exam objectives and turns them into simple explanations so that you can understand what it is you really need to know. And each chapter ends with mock exam questions to help you test yourself. Plus the book has a 70 question final mock exam to take after you have read 636 pages.

This book claims not to be a reference book. But I certainly think you'd come back to this book again and again to look up a quick explanation of how something works. Much development is "trial by fire" and we use something (perhaps through a tool such as XDoclet) without really understanding its fundamentals. When you have time, you can read excerpts from this book to get the fundamentals.

The book’s chapters are the best advice summarized from each of the chapter author’s well-known book on the subject, such as Jason Hunter for the Servlet chapter. Some of the topics covered are best practices for programming in EJB, Servlet, JDBC, XML, RMI, and JSP.

The first chapter highlights EJB best practices, such as the use of CMP Entity Beans whenever possible.

The RMI chapter is the longest chapter at about 30 pages. It has very good code examples and good explanations for RMI best practices. The author is William Grosso. After reading this author, I’d go buy his book to learn more if I needed to do heavy RMI.

The Servlet chapter author Jason Hunter (of Java Servlet Programming) focuses on using the appropriate framework. I was a little surprised Jason didn’t offer more Servlet tips since he’s such a knowledge head on the subject.

The JDBC chapter has some obvious tips to an experienced JDBC programmer. A beginner would find good advice in this chapter.

The XML chapter is excellent. Anything by Brett McLaughlin (of Java and XML) is always excellent. There is no one better to explain how to use XML with Java. Brett offers performance tips for both SAX and DOM programming. He also offers very good tips on writing XML files, e.g. use of attribute over element.

The JSP chapter author Hans Bergsten focuses on design tips. It suggests using JSP for presentation layer only and to combine its use with filters. Some of the tips assumes advanced knowledge. The examples also assume knowledge of JSTL. The chapter is light on code examples. It says to use the TagLibraryValidator and describes the use in 2 short paragraphs with no example code.

This is the fundamental problem of the book. It cannot possibly cover all the best practices with complete explanations and code examples. So to implement some of them, you will need to go to another source. However, for an overview, it is an excellent book. I would recommend it for every project manager and team lead so their development project can follow the industry best practices.

The first edition of this book was published in Sept. 2000. The 2nd edition is updated to cover SDK 1.4, the NIO addition to the Java I/O API, use of web serviced in distributed computing, and J2EE. The J2EE chapters are the bulk of the extra 150 pages in the 2nd edition. They include JDBC, servlets, JSP, and EJB.

Performance tuning is a complicated subject and not for the faint hearted. This book had content and examples easier to understand than many other books I’ve read on the subject.

The book starts you out in the first chapter with some good and basic tuning strategy. The second chapter claims to cover profiling tools. Unfortunately, it only covers what is available from Sun. I would like to have seen 3rd party tools covered. The profile chapter explains what is profiling then how to analyze garbage collection, method calls, object creation, and gross memory use. You’ll finally learn how to really use the Xrunhprof option of the JVM.

Chapter 3 details improvements made in the JDK and how to take advantage. The section on the difference in compilers is informative.

Each chapter ends with a performance checklist. You’ll find this checklist very helpful when implementing the chapter’s suggestions.

Chapter 4 is on Object Creation. In it, you’ll learn how to use a very important “trick” – canonicalization.

Chapter 5 covers Strings. Since Strings are so prevalent in programs, this is a very important chapter. You’ll learn the performance hits you take converting to and from Strings from other types. You’ll also learn the big hit you take with StreamTokenizer and discover the author’s better class. You’ll also understand the significant gain to be had with char arrays over Strings.

If you do a lot of I/O, you’ll find chapter 8 helpful. You can drastically improve your I/O performance! The chapter benchmarks are eye-opening. The chapter also covers the important NIO of the SDK 1.4 and use of non-blocking versus blocking I/O.

Other chapters cover data structures; sorting; distributed computing; and J2EE. A book dedicated only to J2EE would have more on the J2EE subjects. The servlet chapter had simple and obvious performance strategies. The excellent JDBC chapter had a long list of performance check items, which must all be followed for decent performance in any JDBC application.

Not all chapters will apply to your situation. But I bet you’ll be able to use at least 2 chapters' performance tips, making the price of the book very worthwhile.

First, let me say that I don't generally like books with multiple authors. I don't find their content to be very cohesive. Second, let me say that Swing is a very broad topic to cover in a single book. This book takes a stab at it. With 1252 pages, no one is going to sit down and read it cover to cover. Well, if you were writing a very heavy GUI-centric application then maybe you would. I read the chapters that were relevant to the GUI app I was writing at the time. I was disappointed. I found much of the text to be the API documentation. The Swing API is complex and the book's class diagrams are helpful in understanding all the abstraction and interfaces in the API. However, detailing the method descriptions doesn't seem necessary since any programmer would go read the API javadoc. I also found the book's examples to be at a beginner level. And a nitpick on the example code: it doesn't highlight in the code what changed. The chapter starts with a simple program and keeps adding features to it. It'd be very helpful if the additions were highlighted. You have to read the text to pick up what has changed in the revised code.

I was going to not recommend this book. Then I ran into a situation where I needed to highlight multiple terms in an html document. I went to 3 different books to find out how to do this. Not one source told me the complete story. The Java Swing book did tell me one piece: use of the DefaultHighlightPainter. For this reason, I feel I would use Java Swing as a set of reference books on Swing. As I said, not one book is going to cover the complete topic of Swing. And not one book will have enough examples on usage. So any GUI programmer will need to build a library of reference books. This book has the advantage of covering Swing up to JDK 1.4

Java Management Extensions (JMX) is the Java standard for management of application resources. A resource is any hardware or software you wish to monitor and/or control. The concept of managed bean (MBean) is a JMX core concept. JMX is an architecture, design patterns, and an API. JMX can be integrated with SNMP and Web-based Enterprise Management (WBEM).
Book covers:
JMX instrumentation:
MBeans - standard, dynamic, model, and open
JMX notifications
MBean server
Dynamic loading and the M-Let (management applet) service
Agent services - monitoring, timer, relation

Chapter 1: contains excellent definitions. All of the above terms are defined. Explains the overall architecture of JMX. Explains the instrumentation -- each type of MBean and when to use each type. Explains the agent services available, such as M-Let, monitors, timer, and relation. The chapter concludes by walking the user through the sample application which has a producer and consumer. This same application is then used throughout the book.

The writing style is easy to read and understand. The book makes no presumption of knowledge. It has a total of 11 chapters. It gives thorough coverage with easy to understand code examples of the concepts.

When discussing Struts, you first need an understanding of the model-view-controller (MVC) architecture. This book properly starts with a brief explanation of model 1 versus model 2 (MVC) architectures. Then it gives some alternatives to the Struts MVC framework.

The book covers Struts 1.1 and is well written. It doesn't presume any knowledge other than how to write JSP code. It has a good overview of Struts components.

It gives a detailed coverage of each Struts component in the Model/View/Controller architecture. The coverage of Struts custom tags has good explanations of the tags but few code examples. In this area, the Struts documentation is more helpful than this book.

This book includes many other chapters not strictly related to Struts. It does cover Tiles. It also covers logging and how to integrate it with Struts. It shows how to use the built-in servlet container logging, how to use filters for logging, how to use the Jakarta Commons logging package, and how to use the log4j package. The book even covers the use of Ant. Thus the book is a complete web app development resource, not just a Struts tutorial.

There's a chapter that gives good tips on getting better performance from your web app. There's a long list of performance and stress testing tools as a reference resource. I liked the book in its helpfulness in pointing you to other tools that would be helpful in your web app development cycle. You'll spend lots of time on the web looking up all these resources!
Review by: Stephanie Smith
Recommended: Yes.

Mac OS X for Java Geeks
April 2003 282 pages
Will Iverson
O'Reilly
Who needs this book? Anyone who develops Java apps (especially Swing apps) and needs cross-platform compatibility for Mac OS X. Or anyone new to Java and wants to understand the Mac OS X development platform for Java.

I don't use a Mac but this book looks like it would have everything I would need to develop Java programs on a Mac.
Review by: Stephanie Smith
Recommended: Not qualified to judge book since I didn't read it nor apply any of its techniques. I only browsed it as to content and writing style. Both seemed more than adequate.

Jakarta Struts Pocket Reference
June 2003 134 pages
Chuck Cavaness and Brian Keeton
O’Reilly

Pocket references are to refresh your memory on the details. The meat of the book is Part 4. It contains the tags reference. This part alone makes the book worthwhile. Whoever remembers all the different attributes for each of the tags? You need a pocket reference to look up these type of details. The reference even covers Tiles which I thought was a nice bonus. The other parts of the book can be a helpful jog to your memory. Part 1 covers configuration details and the tags you use in the struts-config.xml file. Part 2 covers Action Forms. Part 3 covers Action classes.

This book has made me fall in love with O'Reilly's Cookbook series. If you are not familiar with the Cookbook series, they have the format of problem/solution/discussion. This book covers tools you would use to do Extreme Programming -- small rapid development cycles with complete automated tests. The chapter on Ant has more helpful examples than many entire Ant books I've seen. The chapter on JUnit has enough examples to get you started using JUnit without reading any JUnit documentation! The chapter on Cactus is much more helpful than wading through the Cactus documentation, with the exception of using the JspTestCase. This book does not have a good example of the JspTestCase. The chapter on Tomcat gives you a custom task to start and stop Tomcat. Plus, it tells you how to use the built-in Tomcat custom tasks to hot deploy your web app.

With this book alone, you'll be up and running with the two most used tools in Java development: Ant and JUnit. The book also gives good problems/solutions for many more scenarios: Cactus, HttpUnit, Mock Objects, JUnitPerf, and XDoclet. One caution on the downloaded source code. The HttpUnit examples in the source code required lots of work to get the build file to run and then the unit test to run. I had previously run JUnit and Cactus examples so I knew how to fix the build file. But I never did get the JUnit test to run that used XML and formatted a report. This was curious because this combination had previously run fine in the JUnit chapter. The JUnit test did run for plain format and caught a bug in the source. I don't know if the bug was deliberate or not -- to show the value of the unit test. I fixed the bug and the test passed fine.

Marty's writing style is very easy to understand. His chapters are full of details with code examples to back them up. Some parts of the book refer to his first book Core Servlets and JavaServer Pages. But you don't need the first book (which you can download for free from the internet) to use this book to start writing servlets and JSP code. The examples from the book worked (can't say that for all books!). They were simple to understand yet detailed enough to extrapolate the concept to other uses.

Anyone who writes servlets, JSPs, filters, listeners, or custom tags should read this book. It is not only for those pursuing the WCD certification! This book gives you all the details. You think you know all there is to know about using the JSP tags jsp:usebean, etc.? You don't! Read this book and find out how to really make the most of javabeans in your JSP code.

If you are pursuing WCD certification, this book is a must have. It'll tell you all you need to know to score well on the exam. It covers all the objectives of the exam: servlet model, web deployment, servlet container model, exceptions, session management, security, thread-safety, JSP, reusable components, javabeans, custom tags, and design patterns. The design pattern chapter was in-depth and well-organized -- more coverage than you need for the exam.

What didn't I like? This book is organized by WCD certification exam objectives. So it may not thoroughly cover one topic in a single chapter. For example, listeners are covered under both session management and servlet container model. It would have been more helpful to cover them in one place. I did a lot of jumping back and forth to really understand it all.
I was also disappointed in the source code. Many examples did not run without a lot of tweaking. And some examples did not use the same names in the book for the files so it was hard to find them in the downloaded zip file.

I downloaded this book from the internet. You can buy a hardcopy! 17 chapters and 5 appendices give thorough coverage of everything you need to know about writing EJBs, EJB design, EJB architecture, EJB deployment, clustering, and best practices. Chapters 1 and 2 give you an overview and fundamentals. Managers could stop here! Programmers will move on to chapter 3 to write their first bean. Part 2 of the book will then take the programmer through writing each type of bean. Part 3 of the book starts taking the broader view to design, architect, and implement a complete EJB solution.

Before I read this book, I had attempted to go through the J2EE SDK tutorial. This book was a blessing to find! It's much easier to read and follow than the tutorial. The writing style is not dry and technical. The style instead draws you in with baby steps to completely understand the concepts. The narrative is backed up with plenty of helpful diagrams and code examples.

Whenever I review a beginner Java book, I head straight for the chapters that cover the two most important tenets of OOP - inheritance and polymorphism.

Chapter 8 Serious Polymorphism

This chapter tells you everything you need to know about polymorphism, abstract classes, and inheritance. It poses different design problems for you to design your own solution, using what you've learned. Applying the tenets of polymorphism in a design cements its principles much better than a dry explanation or a brainless exercise that requires you write an interface without design. With this chapter, you'll know how to design a hierarchy and your trade-offs.

Up to this chapter, the reader has learned about concrete classes inheritance, superclasses, subclasses, overloading methods, and overriding methods. The chapter gently introduces the reader to abstract classes and why he/she needs them. The chapter makes it clear how to write them and how to extend from them. Then the chapter poses a problem. It explores different (wrong) ways to solve the problem. Then it explains the beauty of interfaces (and the ugliness of multiple inheritance). Finally, the chapter shows how to have a complete design using a combination of interfaces, abstract classes, and concrete classes.

If I nit-picked, I'd find three short-comings to the chapter. 1) The chapter does not emphasize the implicit cast done at run-time to find the proper method when using a reference type to an abstract class or an interface. It does cover this in the previous chapter on superclasses and subclasses. It's left to the reader to extrapolate this rule would also apply here. 2) The chapter does not talk about the performance overhead of run-time type checking. This discussion probably doesn't belong in a beginner Java book anyway. 3) The chapter mentions the use of instanceof in a brief paragraph but doesn't explain when you might need to make repeated tests (and their hierarchy order). I looked in the index to see if the rule was covered elsewhere and did not find any listing for instanceof.

These minor short-comings should not detract from the true excellence of the chapter. You learn to apply polymorhpism in your design and then to code it in your classes and interfaces.

This book will keep you stimulated! It has plenty of graphics, photos, quizzes, and cartoons to gorge your eyes and brain. The "hand-drawings" and "pencil" type look like notes you'd make yourself. The "pencil" underlining aids in drawing your attention to key points.

I like the category "there are no dumb questions". The questions sound like what an astute student would ask in a Java class. The "sharpen your pencil" category lets you apply what you've learned for your own design. The "Brain Barbell" lets you think about design or programming issues and what the best solution would be. The "Bullet Points" category is a helpful summary of all the key points of the chapter.

Chapters conclude with some challenging exercises, puzzles, and games. They are truly fun and don't feel like "homework". There are true/false, fill in blank, crosswords, match, and cut and paste code magnets exercises.

You are introduced to the Java API early in sections "get to know the Java API". Too many books leave the API out until 2/3 through the book. Since the API is so important to your Java programming, it's good that this book introduces it as soon as it thinks you have a grip on what a class is and a slippery grasp of OOP.

The chapter text is repetitious. They really want you to get the point! They repeat the point in different ways -- cartoons, talking scripts, picture, etc. If you get to the end of the chapter and don't remember what you've read, you were distracted with another media! If you get through all the exercises and still don't know how to apply what the chapter taught, someone else gave you the answers! This book teaches!

This book is also careful to be serious and give you all the rules of the Java language. By the end of the book, you will have a good foundation of the language. For a bonus, you'll know most of the rules you need to know if you go for the Java Programmer Certification. You'll be 75% there in preparation for taking the SCJP exam.

Packaged Composite Applications was written by a SAP "brain trust". SAP is the well-known international publisher of ERP software. It makes the case for a change in architecture. It proposes "Packaged Composite Applications" or PCAs. By using composite applications, the customer can mix and match applications from Oracle, SAP, IBM so his needs are satisfied with the best match. The different applications would integrate together so that data could be shared. The author claims "PCAs are inevitable as a next step for IT". He makes the case:

• Software must be leveraged to reach a new level of productivity.
• Return on investment must be demonstrated.
• It will be difficult to get approval for custom development.
• Processes need to be automated and flexible across application boundaries.

• Once existing technology is fully utilized and optimized, PCAs may not be needed.
• End-user tools can do the job of PCAs.
• Web services will deliver the same results.

 

---