effective-java

I have been reading Effective Java by Joshua Bloch and so far it really lives up to its reputation. The very first item makes a convincing case for static factory methods over constructors . So much that I began to question the validity of the good old constructors :). The advantages/disadvantages from the book are summarized below: Advantages: They have names! We have total instance control (Singletons, performance, etc.) They can return a subtype/interface Compiler can provide type inference Disadvantages: Private classes cannot be subclassed They do not stand out in the documentation as

I am reading the serialization chapter in "Effective Java". I am trying to understand the below paragraph in the book. If you implement a class with instance fields that is serializable and extendable,there is a caution you should be aware of. If the class has invariants that would be violated if its instance fields were initialized to their default values (zero for integral types, false for boolean, and null for object reference types), you must add this readObjectNoData method to the class: // readObjectNoData for stateful extendable serializable classes private void readObjectNoData()

From Effective Java ( Item 1 : Consider static factory methods instead of constructors ): The class of the object returned by a static factory method need not even exist at the time the class containing the method is written. Such flexible static factory methods form the basis of service provider frameworks, such as the Java Database Connectivity API (JDBC). A service provider framework is a system in which multiple service providers implement a service, and the system makes the implementations available to its clients, decoupling them from the implementations. I specifically do not understand

In Effective Java (Chapter 7), it says Note also that we did not use Date’s clone method to make the defensive copies. Because Date is nonfinal, the clone method is not guaranteed to return an object whose class is java.util.Date: it could return an instance of an untrusted subclass specifically designed for malicious mischief. Such a subclass could, for example, record a reference to each instance in a private static list at the time of its creation and allow the attacker to access this list. This would give the attacker free reign over all instances. To prevent this sort of attack, do not

How do I make defensive copies of a Mutable Object which contains a mutable field in an Immutable Object? class ImmutableObject { private final MutableObject immutable_field; ImmutableObject(MutableObject y) { this.immutable_field = y; } } class MutableObject { public int mutable_field; } The MutableObject does not have a constructor that lets me set the field. The MutableObject's current state should be captured in the Immutable Object and never changed. What you need to do is in MutableObject return_immutable_field() { return immutable_field; } Change to: MutableObject return_immutable_field

This is from Effective Java Programs that use the int enum pattern are brittle. Because int enums are compile-time constants, they are compiled into the clients that use them. Can some one explain why the int enum pattern is called compiled type constant and what is meant by compiled into the clients ? Here s' an example of such a constant : public static final int APPLE_FUJI = 0; Suppose you have two files: Foo.java: public class Foo { public static final int SOMETHING = 1; } Bar.java: public class Bar { public static void main(String[] args) { System.out.println(Foo.SOMETHING); } } Compile

I was going through Effective Java book , and creating notes for my future reference , i came across Builder Pattern. Well i understood what it is and how its suppose to be used.In the process i created a two example variations of the builder pattern. I would need help in listing down the differences and the advantage each has? Well i certainly noticed that , Example 1 exposes less methods , there by less restrictive and more generic , there by allowing it to be used more flexibly. Please point out other things i have missed? Example 1 package item2; /** * @author Sudhakar Duraiswamy * */