What do you think?
Rate this book
Effective Java: Best Practices für die Java-Plattform (Programmieren mit Java)
Seit der Vorauflage von "Effective Java", die kurz nach dem Release von Java 6 erschienen ist, hat sich Java dramatisch verändert. Dieser preisgekrönte Klassiker wurde nun gründlich aktualisiert, um die neuesten Sprach- und Bibliotheksfunktionen vorzustellen. Erneut zeigt Java-Kenner Joshua Bloch anhand von Best Practices, wie Java moderne Programmierparadigmen unterstützt.
Wie in früheren Ausgaben besteht jedes Kapitel von "Effective Java" aus mehreren Themen, die jeweils in Form eines kurzen, eigenständigen Essays präsentiert werden. Dieses enthält jeweils spezifische Ratschläge, Einblicke in die Feinheiten der Java-Plattform und Codebeispiele. Umfassende Beschreibungen und Erklärungen für jedes Thema beleuchten, was zu tun ist, was nicht zu tun ist und warum es zu tun ist.
Die dritte Auflage behandelt Sprach- und Bibliotheksfunktionen, die in Java 7, 8 und 9 hinzugefügt wurden, einschließlich der funktionalen Programmierkonstrukte. Neue Themen sind unter anderem:
Functional Interfaces, Lambda-Ausdrücke, Methodenreferenzen und Streams Default- und statische Methoden in Interfaces Type Inference, einschließlich des Diamond-Operators für generische Typen Die Annotation @SafeVarargs Das Try-with-Resources-Statement Neue Bibliotheksfunktionen wie das Optional Interface, java.time und die Convenience-Factory-Methoden für Collections413 pages, Kindle Edition
First published June 5, 2001
1865 people are currently reading
8232 people want to read
About the author
Joshua Bloch
9 books143 followersThere is more than one Joshua Bloch in the GR database. This is Joshua^Bloch, author of computing books.
Ratings & Reviews
Friends & Following
Create a free account to discover what your friends think of this book!
Community Reviews
Displaying 1 - 30 of 422 reviews
February 12, 2012
This is the single best book I have seen or read about Java to date. Bloch, who has been involved in the development of the latest versions of the Java language and specification, does not teach how to write Java code; he teaches how to write GOOD Java code.
This is a MUST READ for anyone who plans to write more than a little bit of Java code. But not only that, it is fairly easy to read and rather interesting.
I had a few second thoughts after writing the review above, so I thought I'd better add two things. First, make sure you get the most recent edition of the book as there have been substantial changes. Second, this is not a beginner's book - you won't find "HelloWorld" here. Learn the Java basics first.
This is a MUST READ for anyone who plans to write more than a little bit of Java code. But not only that, it is fairly easy to read and rather interesting.
I had a few second thoughts after writing the review above, so I thought I'd better add two things. First, make sure you get the most recent edition of the book as there have been substantial changes. Second, this is not a beginner's book - you won't find "HelloWorld" here. Learn the Java basics first.
April 11, 2013
Score: 3.5/5
Effective Java: even the title is concise and to-the-point, like the rest of the book's writing. This is not a book for beginners, but rather a book on general software design concepts, particularly with respect to Java itself. The book is organized into a few dozen "items", most of which follow this format:
1) "Here's a suggestion. You should probably follow it."
2) "Here's an example of following it, here's an example of why not following it is bad, and here's an example of when you can ignore this suggestion."
and then you've read that item.
The good examples are good, and there's a lot to learn about writing software in general. He starts off with a solid defense of static factory methods (Item 1), offers patterns for successfully avoiding multithreading issues (Item 48) and serialization issues (Item 54), and even has sound general programming advice (Item 30: "Know and use the libraries", or Item 37: "Optimize judiciously").
Some of the suggestions seem to hinge on the assumption that the code you write is well-thought-out, such as Item 13: "Minimize the accessibility of classes and members." On the one hand, a well-designed module will be self-contained, easily usable via its publicly exposed methods, and will be more maintainable because of limited scope. On the other hand, how much code duplication occurs because a module's fields are private when they could be protected, or because certain parts of its implementation aren't exposed that should otherwise be reused?
When faced with a compromise between writing extra code and entertaining the possibility of a client using your code in a way differently than you intended, Bloch always chooses writing extra code. The classic "favor composition over inheritance" (Item 14) is a great example of this, with his InstrumentedSet example marred by an unruly horde of "forwarding methods".
Bloch never questions the language itself, but instead sometimes uses its design "decisions" as justification for suggestions. From Item 35, "Prefer interfaces to reflection", after providing a code example of using reflection (emphasis added):
I understand that this book is about how to code in Java, but using the inconvenience of writing meta-code in Java as a reason to not write it (especially after how willing he is to add plenty of forwarding methods), instead of commenting on the language's design or pointing out in how many languages you could write the example in one line, is inexcusable.
Bloch seems endlessly concerned with a potential "attacker" of your code (Item 3: "enforce noninstantiability with a private constructor", or Item 24: "make defensive copies when needed")---though not as much against "people maliciously accessing your servers" concern as "clients using your library in ways you did not intend them to." This has, of course, always been a dispute between Java programmers and Python/Perl/Ruby/JS developers in terms of how "open" libraries should be to manipulation if you need them to do something just slightly different than intended. I do find it amusing, however, given the existence of Java's reflection API---if someone wanted to "maliciously" misuse your API, the language won't stop them, but will just make it more difficult.
I'm reminded of the ending from Steve Yegge's "Wikileaks to Leak 5000 Open Source Java Projects With All That Private/Final Bullshit Removed":
This book deserves its reputation for being good at what it does: teaches you to write better Java. But the context is still Java, with all of its strengths and weaknesses. For better or worse, Bloch is writing about Java as it is, and not as it could be, and his assumptions about the reader's quality of judgment make you wonder how much code duplication he has inadvertently caused.
Effective Java: even the title is concise and to-the-point, like the rest of the book's writing. This is not a book for beginners, but rather a book on general software design concepts, particularly with respect to Java itself. The book is organized into a few dozen "items", most of which follow this format:
1) "Here's a suggestion. You should probably follow it."
2) "Here's an example of following it, here's an example of why not following it is bad, and here's an example of when you can ignore this suggestion."
and then you've read that item.
The good examples are good, and there's a lot to learn about writing software in general. He starts off with a solid defense of static factory methods (Item 1), offers patterns for successfully avoiding multithreading issues (Item 48) and serialization issues (Item 54), and even has sound general programming advice (Item 30: "Know and use the libraries", or Item 37: "Optimize judiciously").
Some of the suggestions seem to hinge on the assumption that the code you write is well-thought-out, such as Item 13: "Minimize the accessibility of classes and members." On the one hand, a well-designed module will be self-contained, easily usable via its publicly exposed methods, and will be more maintainable because of limited scope. On the other hand, how much code duplication occurs because a module's fields are private when they could be protected, or because certain parts of its implementation aren't exposed that should otherwise be reused?
When faced with a compromise between writing extra code and entertaining the possibility of a client using your code in a way differently than you intended, Bloch always chooses writing extra code. The classic "favor composition over inheritance" (Item 14) is a great example of this, with his InstrumentedSet example marred by an unruly horde of "forwarding methods".
Bloch never questions the language itself, but instead sometimes uses its design "decisions" as justification for suggestions. From Item 35, "Prefer interfaces to reflection", after providing a code example of using reflection (emphasis added):
You can see two disadvantages of reflection in the example. First, the example is capable of generating three run-time errors, all of which would have been compile-time errors if reflective instantiation were not used. Second, it takes twenty lines of tedious code to generate an instance of the class from its name, whereas a constructor invocation would fit neatly on a single line.
I understand that this book is about how to code in Java, but using the inconvenience of writing meta-code in Java as a reason to not write it (especially after how willing he is to add plenty of forwarding methods), instead of commenting on the language's design or pointing out in how many languages you could write the example in one line, is inexcusable.
Bloch seems endlessly concerned with a potential "attacker" of your code (Item 3: "enforce noninstantiability with a private constructor", or Item 24: "make defensive copies when needed")---though not as much against "people maliciously accessing your servers" concern as "clients using your library in ways you did not intend them to." This has, of course, always been a dispute between Java programmers and Python/Perl/Ruby/JS developers in terms of how "open" libraries should be to manipulation if you need them to do something just slightly different than intended. I do find it amusing, however, given the existence of Java's reflection API---if someone wanted to "maliciously" misuse your API, the language won't stop them, but will just make it more difficult.
I'm reminded of the ending from Steve Yegge's "Wikileaks to Leak 5000 Open Source Java Projects With All That Private/Final Bullshit Removed":
"[This is what] Java developers who release Open Source […] code are saying: 'Here, I worked hard on this. I hope you like it. But use it exactly how I tell you to use it, because fuck you, it's my code. I'll decide who's the goddamn grown-up around here."
This book deserves its reputation for being good at what it does: teaches you to write better Java. But the context is still Java, with all of its strengths and weaknesses. For better or worse, Bloch is writing about Java as it is, and not as it could be, and his assumptions about the reader's quality of judgment make you wonder how much code duplication he has inadvertently caused.
December 26, 2010
Effective Java is THE BOOK you want to read first when you start writing Java code professionally (for a living).
In the style of Scott Meyer's C++ books, Joshua Bloch - the head behind several modern Java libraries - presents the essential tricks of the trade and best practises when it comes to Java programming. This is essential when you want to write highly maintainable, efficient modern Java code.
The second edition puts a lot of emphasis on all the new language features that came with Java 5 and especially how they made past best practises obsolete. This is exactly what you don't get by reading general Java programming books or tips online - most of which is old and just not the best implementation possible. Implementation issues are treated from the perspective of API maintainability. This aims for very high quality standards (e.g. libraries) but is nevertheless interesting for every Java programmer. We are all writing APIs of some sort - in the extreme case just for ourselves.
This book can safe you a lot of future headaches!
In the style of Scott Meyer's C++ books, Joshua Bloch - the head behind several modern Java libraries - presents the essential tricks of the trade and best practises when it comes to Java programming. This is essential when you want to write highly maintainable, efficient modern Java code.
The second edition puts a lot of emphasis on all the new language features that came with Java 5 and especially how they made past best practises obsolete. This is exactly what you don't get by reading general Java programming books or tips online - most of which is old and just not the best implementation possible. Implementation issues are treated from the perspective of API maintainability. This aims for very high quality standards (e.g. libraries) but is nevertheless interesting for every Java programmer. We are all writing APIs of some sort - in the extreme case just for ourselves.
This book can safe you a lot of future headaches!
April 16, 2020
Well, I've been staring at the screen and trying to rate this book for at least 20 minutes, all the while changing my mind every other minute or so. Writing a review for it is making me equally conflicted but at least in the review I'm not limited to only two options (3 or 4 stars, if anyone's wondering).
First thing to say is that Joshua Bloch is a competent enough author - a bit dry but always to the point, clear, precise and thorough. And he really knows his Java - so much so that I regret not having read this book (well, the previous edition at least) some 10 years ago when I was just starting out - it's definitely more useful to beginners and I could have learned a ton!
The items themselves present the reader with sound advice but the choice of the items is what I take issue with:
* some items read like they were written ~15 years ago for C++ folks moving to Java (enums and bitmaps, native code warnings)
* others read like they were written to highlight old anti-patterns that probably very few devs use in this day and age (finalizers, clone, Serializables, wait/notify, yield...)
* a few have disproportionate amount of space devoted to them given their importance (see previous point and add to it toString, hashCode & equals and probably a few others)
* lots of them (by author's own admission) are more applicable of you're writing a library or framework intended for wide audiences/public use and seem needlessly defensive
Summed up, the criticism amounts to this - while all the items included within are valid, the book would have had more to offer and reader to gain from cutting some of them short (or throwing them out completely) and replacing them with more practically useful items. What about I/O? Don't tell me there's nothing to say. And where are CompletableFutures, asynchronous and non-blocking programming? More from java.util.concurrency and Java's standard library in general?
Or maybe I'm just a splendid curmudgeon in the making...
First thing to say is that Joshua Bloch is a competent enough author - a bit dry but always to the point, clear, precise and thorough. And he really knows his Java - so much so that I regret not having read this book (well, the previous edition at least) some 10 years ago when I was just starting out - it's definitely more useful to beginners and I could have learned a ton!
The items themselves present the reader with sound advice but the choice of the items is what I take issue with:
* some items read like they were written ~15 years ago for C++ folks moving to Java (enums and bitmaps, native code warnings)
* others read like they were written to highlight old anti-patterns that probably very few devs use in this day and age (finalizers, clone, Serializables, wait/notify, yield...)
* a few have disproportionate amount of space devoted to them given their importance (see previous point and add to it toString, hashCode & equals and probably a few others)
* lots of them (by author's own admission) are more applicable of you're writing a library or framework intended for wide audiences/public use and seem needlessly defensive
Summed up, the criticism amounts to this - while all the items included within are valid, the book would have had more to offer and reader to gain from cutting some of them short (or throwing them out completely) and replacing them with more practically useful items. What about I/O? Don't tell me there's nothing to say. And where are CompletableFutures, asynchronous and non-blocking programming? More from java.util.concurrency and Java's standard library in general?
Or maybe I'm just a splendid curmudgeon in the making...
March 21, 2017
I read this book as a recommended reading for the Java developers at Google. I found many "items" described in this book quite useful in real-life coding. Sometimes the author has gone a little too far to describe a single item, but overall the book is very well written.
October 20, 2019
This book was exactly what I expected it to be.
June 24, 2019
An amazing book about Java and its different features. If you are a Java programmer, you will benefit a lot and learn a lot by reading this book. Whenever you want to pick up this book, make sure you take the latest edition as it changes a lot to accommodate new updates in the language and its libraries.
I have summarized the entire book (3rd edition) here!
This includes a summary of each item with its code examples in a way that is more concise and understandable.
I have summarized the entire book (3rd edition) here!
This includes a summary of each item with its code examples in a way that is more concise and understandable.
August 8, 2019
Some items were a little bit advanced for me as a beginner. Not so much in a sense that they were hard to understand, but they seemed so far away from me to even think about them at the first place or grasp their importance. But, I'm pretty sure that as my programming career continues I'll pick up this book as a reference and be able to appreciate it more.
January 27, 2017
I started reading it to improve my knowledge of java and it was exactly what I found.
The books is separated in 78 items with begin and end, so reading an item who is 2 to 3 pages long, you end with a new approach to something.
It is really an enjoyable experience :)
The books is separated in 78 items with begin and end, so reading an item who is 2 to 3 pages long, you end with a new approach to something.
It is really an enjoyable experience :)
September 14, 2018
The introduction and middle of the book are awesome, with incredible new informations about Java. After, there are some chapters very boring, for example, about the JavaDoc.
Even if the book still very good.
Even if the book still very good.
April 16, 2009
Although it is a bit outdated, 90% of the book contains great advise for any Java programmer. If you have not read this then you do not know how to program Java.
-m
-m
May 7, 2020
Recommended for anyone who is doing full time professional Java development. Bloch well-codifies a lot of the otherwise cargo-culted tribal knowledge and conventions that are out there, as well as shedding light on many of the weird cases that we run into everyday. And/but/so then there's a bunch of items that are NOT a part of my everyday ... though I'm sure that's just a matter of circumstance, and for someone out there: they are.
It gets pretty technical in places and by necessity can get into the weeds, but most of the content should be accessible to journeyman developers, as well as committed novices.
It gets pretty technical in places and by necessity can get into the weeds, but most of the content should be accessible to journeyman developers, as well as committed novices.
June 21, 2020
I found this book by asking a simple question, which books are mandatory reading to learn about Java. Once I finished it I realized it also answered another question, "which books are recommended reading for any software developer". Often times when trying to learn a new language or improve knowledge on a familiar one, it feels like most available literature is aimed at students learning to code or at experienced developers trying to improve some highly technical knowledge. The books that I find the best are the ones that are about learning from experience. That's how this books feels, not as a glossary on how to code in Java, but instead as a personal blog of an experienced developer going through learned lessons and past mistakes.
July 21, 2024
I took a few pages worth of notes, and all in all, this booked helped me either grip a better understanding of concepts I had an idea of, or reminded me of certain ideas which I've lost in my memory. I enjoyed reading the chapters, the book is readable while commuting on railways etc. Maybe Serilization and Generics chapters could have been edited better, but all in all, quite understandable concepts.
I wish the book had some more up-to-date editions; almost all new version of Java since 9 had some new features in terms on concurrency.
I would recommend watching Venkat Subramaniam's conference recordings on Youtube over reading this book - I think his seminars complement this book nicely.
I wish the book had some more up-to-date editions; almost all new version of Java since 9 had some new features in terms on concurrency.
I would recommend watching Venkat Subramaniam's conference recordings on Youtube over reading this book - I think his seminars complement this book nicely.
July 7, 2019
This is an amazing book for Java developers and it shows that Joshua really knows his stuff. It clarifies and shows in deep details the internals of Java and how it should be used in order for you to be more effective.
It is a great reading and I strongly recommend it. It is important to notice that as this book shows 90 recommendations, it is hard for the reader to remember everything, so you should use it as a reference book when you are going to implement something. Personally, I have printed the chapter titles, so I remember to study the specific recommendation when I am creating something new.
The author was responsible for architecting and implementing many Java features and he exposes good and bad practices of many libraries that we use today, so we have a better understanding of what to use and not to use.
In summary, read this book! :)
It is a great reading and I strongly recommend it. It is important to notice that as this book shows 90 recommendations, it is hard for the reader to remember everything, so you should use it as a reference book when you are going to implement something. Personally, I have printed the chapter titles, so I remember to study the specific recommendation when I am creating something new.
The author was responsible for architecting and implementing many Java features and he exposes good and bad practices of many libraries that we use today, so we have a better understanding of what to use and not to use.
In summary, read this book! :)
May 14, 2025
Truly excellent for intermediate Java programmers. It will help you understand why to do things one way and not another.
The edition I read is out of date now, but I bought the 3rd edition, went over what changed and conclude it is of the same high quality, and covered the truly significant changes that came with Java 7 and 8.
Of course, Java 24 has been out for a couple months as I write this (and 21, the most recent Long Term Support version since 2023), but most of the advice in the book is still quite relevant.
The edition I read is out of date now, but I bought the 3rd edition, went over what changed and conclude it is of the same high quality, and covered the truly significant changes that came with Java 7 and 8.
Of course, Java 24 has been out for a couple months as I write this (and 21, the most recent Long Term Support version since 2023), but most of the advice in the book is still quite relevant.
July 10, 2025
Possibly the best programming book I've read (though I haven't read that many). It's so nice to read best practices advice that is accompanied by solid, clear explanations of *why* it's a best practice, when it's worth breaking the rules, and well-written examples.
I got this through interlibrary loan and I'm bummed I'll have to return it. I may buy a copy now, and if an updated edition for Java 21 was released, I would immediately buy that too.
I got this through interlibrary loan and I'm bummed I'll have to return it. I may buy a copy now, and if an updated edition for Java 21 was released, I would immediately buy that too.
October 20, 2020
Fantastic book that any Java developer should read at some point in their career (preferably earlier on)! Very well laid out and contains many invaluable principles/conventions with good explanations that, when followed, will improve the code you produce.
December 8, 2024
A thrilling read
July 25, 2022
Really helped me build the craftsmanship of writing Java
December 4, 2017
good one
December 27, 2019
The very best book about this topic. I learned lot from this book — thanks to authors.
July 10, 2018
Můj osobní etalon skvělé programátorské knížky: spousta užitečných informací; minimum balastu; užitečné reference, kam jít dál; vysvětlení, proč věci jsou tak, jak jsou.
Je to již potřetí, co jsem tuto knížku četl, pokaždé v nové edici. A popravdě je to poprvé, co jsem nad pěti hvězdami zaváhal. Nemůže za to ale asi autor, ale samotná podstata věci. Java je prostě už stará. Knížka už ani tak neřeší, jak psát věci efektivně, jako kterým oblastem jazyka se vyhnout. Nějak automaticky se mi vybavuje název české knížky o C++: "Pasti a pastičky". Občas mi totiž při čtení bylo smutno, čím vším si případný nováček musí projít a co na něj číhá za strašidla.
Samozřejmě jsem se naučil řadu nových věcí (hlavně řadu "pomocných" metod postupně přidaných do knihovny jazyka), ale zároveň vím, že jsem daleko víc nepobral a budu rád, když si o těchto tématech alespoň udržím povědomí a pak budu moct "šáhnout do šuplíku" a znova zapátrat.
Čtěte, kupujte... nevím, je to patetické, ale nic lepšího mě nenapadá.
Je to již potřetí, co jsem tuto knížku četl, pokaždé v nové edici. A popravdě je to poprvé, co jsem nad pěti hvězdami zaváhal. Nemůže za to ale asi autor, ale samotná podstata věci. Java je prostě už stará. Knížka už ani tak neřeší, jak psát věci efektivně, jako kterým oblastem jazyka se vyhnout. Nějak automaticky se mi vybavuje název české knížky o C++: "Pasti a pastičky". Občas mi totiž při čtení bylo smutno, čím vším si případný nováček musí projít a co na něj číhá za strašidla.
Samozřejmě jsem se naučil řadu nových věcí (hlavně řadu "pomocných" metod postupně přidaných do knihovny jazyka), ale zároveň vím, že jsem daleko víc nepobral a budu rád, když si o těchto tématech alespoň udržím povědomí a pak budu moct "šáhnout do šuplíku" a znova zapátrat.
Čtěte, kupujte... nevím, je to patetické, ale nic lepšího mě nenapadá.
October 5, 2018
I have read the 3rd edition of this book, which is updated for Java 8. It’s a collection of 90 best practices for developers. Those practices cover a wide range of mostly used Java features, including generics, exceptions, concurrency, serialization, lambdas and many others.
A lot of relevant code examples showing both the good and the bad code followed by a robust explanation. The focus is on developers who create APIs that others will use, however IMHO everyone writing in Java would benefit from this book.
I wouldn’t recommend this book to beginners who are not yet fluent in various aspects of Java. The examples are complex and can be confusing for someone with little experience. I tried to read the previous version when I still had little experience. I have found the book too difficult and I gave up after just 30 pages. Having a couple more years of Java coding in my life I have tried again and this time it has been a blast. I have learned a lot and will use this book as reference throughout my career.
Thanks to mr Bloch for this great book.
A lot of relevant code examples showing both the good and the bad code followed by a robust explanation. The focus is on developers who create APIs that others will use, however IMHO everyone writing in Java would benefit from this book.
I wouldn’t recommend this book to beginners who are not yet fluent in various aspects of Java. The examples are complex and can be confusing for someone with little experience. I tried to read the previous version when I still had little experience. I have found the book too difficult and I gave up after just 30 pages. Having a couple more years of Java coding in my life I have tried again and this time it has been a blast. I have learned a lot and will use this book as reference throughout my career.
Thanks to mr Bloch for this great book.
August 28, 2021
Better to re-read regularly, with great focus.
June 20, 2010
This is a unique and very worthwhile work for experienced Java developers who want to take their Java skills to the next level. It assumes that the reader is fully comfortable programming in Java, and gives a collection of tips on how to exploit certain language features, how to avoid various pitfalls, and so forth. The book makes frequent reference to design patterns, but it is not a design patterns book. It is also distinct from a “software engineering” book, but rather concentrates on aspects of Java that are do (or do not) accomplish various software engineering goals. The author does not hesitate to point out inadequacies and inconsistencies in the Java language itself, often as cautionary tales to illustrate the consequences of insufficiently thought-out design decisions made early in the language’s life.
I give Effective Java my highest recommendation.
I give Effective Java my highest recommendation.
May 13, 2012
If most programmers consider Core Java to be the best book for beginners, they should think about “Effective Java” as the best book for intermediate and more advanced Java programmers.
After this book my awareness about how good Java code should look like improved a lot. I learnt a lot of interesting and useful approaches to developing code in different situations. And, in spite of being heavily packed of knowledge, I can not say that reading this book was difficult. It was a nice lecture although some topics are more complicated and forced me to slow down and analyse paragraphs one by one. More on my blog post.
After this book my awareness about how good Java code should look like improved a lot. I learnt a lot of interesting and useful approaches to developing code in different situations. And, in spite of being heavily packed of knowledge, I can not say that reading this book was difficult. It was a nice lecture although some topics are more complicated and forced me to slow down and analyse paragraphs one by one. More on my blog post.
November 4, 2013
Before I head off to Google in NYC next February, I'm doing three months of contract work for a Java shop in Atlanta. I picked this up to refresh my Java skills, which have grown rusty in the decade-plus since taking and then TA'ing the Java-based Introduction to Computer Science as a freshman at GT. A quick and useful guide in the line of Scott Meyers's Effective C++ and More Effective C++, on which Mr. Bloch seems to have consciously based his book.
July 9, 2010
If you program Java, you must read this book. You won't learn any new syntax, language feature, library, or framework, but you will be a much better programmer as a result of reading this book. Its the best anything on Java I have read. I don't agree with 100% of the material in this book, but Joshua Bloch has a strong, clear opinions and he argues them well. This book is so good, I think you should read it even if you aren't a Java programmer but program C#, C++, or something else along those lines. Even Ruby and Python programmers will probably get a lot out of this book.
August 10, 2010
This book impressed me with the amount of practical use-cases of Java subtleties and intricacies -- for example, the proper implementation of "equals" method in classes.
The author not only shows us some common misconceptions about the "low level" Java mechanics (not the native level, but the basics of the language and the Java API), but also gives us many examples from his rich carreer.
It is my opinion that understanding the basics of Java (it turns out many of us don't) is the key to avoiding mistakes which are subsequently very hard to track, and this book helps exactly with this.
The author not only shows us some common misconceptions about the "low level" Java mechanics (not the native level, but the basics of the language and the Java API), but also gives us many examples from his rich carreer.
It is my opinion that understanding the basics of Java (it turns out many of us don't) is the key to avoiding mistakes which are subsequently very hard to track, and this book helps exactly with this.
Displaying 1 - 30 of 422 reviews