Effective Java™ Programming Language Guide (Java Series (Old Edition))

Si ya tienes experiencia en Java, este libro es el mejor que puedes adquirir. Tiene numerosos consejos sobre cómo diseñar en Java y escribir código más eficiente y con menos bugs. "Must have" para cualquier desarrollador Java.

If you work with Java (I mean really work in a company or at a university) this book is a must-read. It gives you some real good insights in the language and let's you avoid certain pitfalls. The edition I bought was a little bit out-dated and if Java 8 comes sometime (haha...;) it will be even more out-dated. However, the pitfalls will stay the same, Java is downwards compatible.

It has been an absolute pleasure to read this no-nonsense collection of observations and suggestions.The author is extremely knowledgeable and articulates his points in a clear, concise and logical presentation, which is a rare characteristic in today's overflowed and low-quality offer of "how-to-become-a-guru" manuals.The Collections framework is clearly the author's backyard and you will learn about implementation details and rationales that you will not easily find anywhere else.What I found most useful in the analysis of the various Java aspects was the author's perspective, which is based on the pros and cons of implementation choices, and strongly focused on API construction. Unless you work alone and deliver complete applications, you will define, design and implement an API sooner or later, maybe even without realizing it. With the help from this book you will most certainly design a robust, maintainable and useful API.I also liked the practical approach that sometimes goes against OO principles: for example, just because Java embraced the OO philosophy does not mean that inheritance is the only way to go. Composition, static factories, singletons, immutable classes and some good old procedural programming are discussed in depth.Another brilliant characteristic of this guide (and I would like to especially thank the author for this) is that although there are plenty of snippets to illustrate concepts, these are just skeletons, never longer than few lines and therefore they do not force you to waste your time and divert your attention from the core issue by analyzing pages over pages of code when maybe only one line could have served the purpose.I would say that this book finds its best audience in the experienced developer/architect who does not have a specific Java expertise but is very comfortable with some other programming language. However, everyone can benefit from in-depth explanations of often misunderstood subtleties like the "equals()", "hashCode()", "clone()" or "compareTo()" contracts. Or serialization: are you sure you master it?You don't need a profound Java working experience to immediately grasp some concepts; I found that this guide was an excellent companion in my learning of Java, you can start reading it from day 0, and you will get back to it every time you want to know more about a new concept.The best praise I can say about "Effective Java" is that in my opinion only a handful of experts in the whole Java community could rightfully say "This book shall not teach me no thing", and then I would like to work with these people.

This book contains a generous cross-section of the knowledge that differentiates Java gurus from advanced Java programmers.I've been working full-time in Java since 1995, prior to version 1.0. I've also written books and articles on Java and have been teaching Java at the University level as a sideline for four years. In that time I've accumulated a great deal of "expert" knowledge about the language, the JVM, and the APIs and developed opinions on the best approaches to use in Java. At this point, reading books such as this that contain a collection of tips and advice I am usually satisfied to gain one new piece of knowledge; I learned at least six new things from this book.Of the 50+ books on Java I've read, this book contains by far the most comprehensive and useful collection of that hard-won knowledge of core Java. The bonus is the clear and concise manner in which it is presented.Bloch is dead-on. There isn't a single factual error or piece of bad advice in the book. The most I came up with were a couple of omissions on some of the topics. However, omissions are inevitable given the technical depth of some of the topics Bloch covers, such as serialization, exceptions and threads.I offer only two caveats about the book. The first is that the book is for advanced Java programmers. This is not to say that this information is not useful to every Java programmer, but you need to have a comprehensive knowledge of Java in order to appreciate many of the topics. This book does not provide comprehensive coverage, but rather fills in the detail and subtleties. I teach a Java IV class and recommend this to my students as additional reading after completing the class.The other caveat is that this book is written from the perspective of writing public APIs. Bloch is the lead architect for the core JDK APIs where the classes and APIs have special security considerations. Several pieces of advice he gives apply absolutely to a public API where you want to defend the API from malicious code. However, if the code you are creating is intended for a less hostile and more trusting environment, fully following all of his advice will result in unnecessarily complex code. The one knock I give to the book is that Bloch does not delineate the circumstances that would dictate following his rather rigorous approach to bullet-proofing an API and can leave the reader with the mistaken perception that the advice applies equally to all categories of code.Overall, this is absolutely a must-have book for the experienced Java programmer. Even if you are not yet an advanced Java programmer, buy this book and keep revisiting it as you advance until everything in the book makes sense to you.

Even the first edition is an excellent guide for good programming practices. Whilst there are similar books (by different authors) which aim at C#, the arguments Bloch presents here for certain practices (eg composition over inheritance; using static factory methods; a host of other examples) are clearly stated and persuasive and apply equally well to C#. Of course, a few sections in the first edition no longer apply (or should be supplemented) but, beginners aside, most should be able to sift out the useful information.