effective-java-2nd

public static Boolean valueOf(boolean b) {
    return b ? Boolean.TRUE : Boolean.FALSE;
}

// Does not scale well!
public class NutritionFacts {
    private final int servingSize;     // required
    private final int servings;        // required
    private final int calories;        // optional
    private final int fat;             // optional
    private final int sodium;          // optional
    private final int carbohydrate;    // optional

    public NutritionFacts(int servingSize, int servings) {
        this(servingSize, servings, 0);
    }

    public NutritionFacts(int servingSize, int servings,
                          int calories) {
        this(servingSize, servings, calories, 0);
    }

    public NutritionFacts(int servingSize, int servings,
                          int calories, int fat) {
        this(servingSize, servings, calories, fat, 0);
    }

    public NutritionFacts(int servingSize, int servings,
                          int calories, int fat, int sodium) {
        this(servingSize, servings, calories, fat, sodium, 0);
    }

    public NutritionFacts(int servingSize, int servings,
                          int calories, int fat, int sodium,
                          int carbohydrate) {
        this.servingSize       = servingSize;
        this.servings          = servings;
        this.calories          = calories;
        this.fat               = fat;
        this.sodium            = sodium;
        this.carbohydrate      = carbohydrate;
    }
}

public class NutritionFacts {
    // Parameters initialized to default values (if any)
    private int servingSize   = -1; // Required; no default value
    private int servings = -1;
    private int calories = 0;
    private int fat      = 0;
    private int sodium   = 0;
    private int carbohydrate  = 0;

    public NutritionFacts() { }

    // Setters
    public void setServingSize(int val) {
        servingSize = val;
    }

    public void setServings(int val) {
        servingSize = val;
    }

    public void setCalories(int val) {
        calories = val;
    }

    public void setFat(int val) {
        fat = val;
    }

    public void setSodium(int val) {
        sodium = val;
    }

    public void setCarbohydrate(int val) {
        carbohydrate = val;
    }
}

public class NutritionFacts {
    private final int servingSize;
    private final int servings;
    private final int calories;
    private final int fat;
    private final int sodium;
    private final int carbohydrate;

    public static class Builder {
        // Required parameters
        private final int servingSize;
        private final int servings;

        // Optional parameters - initialized to default values
        private int calories       = 0;
        private int fat            = 0;
        private int carbohydrate   = 0;
        private int sodium         = 0;

        public Builder(int servingSize, int servings) {
            this.servingSize = servingSize;
            this.servings = servings;
        }

        public Builder calories(int val) {
            calories = val;
            return this;
        }

        public Builder fat(int val) {
            fat = val;
            return this;
        }

        public Builder carbohydrate(int val) {
            carbohydrate = val;
            return this;
        }

        public Builder sodium(int val) {
            sodium = val;
            return this;
        }

        public NutritionFacts build() {
            return new NutritionFacts(this);
        }
    }

    private NutritionFacts(Builder builder) {
        servingSize   = builder.servingSize;
        servings      = builder.servings;
        calories      = builder.calories;
        fat           = builder.fat;
        sodium        = builder.sodium;
        carbohydrate  = builder.carbohydrate;
    }
}

NutritionFacts cocaCola = new NutritionFacts.Builder(240, 8).
    calories(100).sodium(35).carbohydrate(27).build()

def info(object, spacing=10, collapse=1):
    pass

# With only one argument, spacing gets its default value of 10 and collapse gets
# its default value of 1
info(odbchelper)
# With two arguments, collapse gets it default value of 1
info(odbchelper, 12)
# Here you are naming the collapse argument explicitly and specifying its value,
# spacing still gets its default value of 10
info(odbchelper, collapse=0)
# Even required arguments(like object, which has no defult value) can be named,
# and named arguments can appear in any order
info(spacing=15, object=odbchelper)

// Enum singleton - the preferred approach
public enum Elvis {
    INSTANCE;

    public void leaveTheBuilding() {
        //...
    }
}

enum Singleton {
    INSTANCE;

    // instance vars, constructor
    private final Connection connection;

    Singleton() {
        // Initialize the connection
        connection = DB.getConnection();
    }

    // Static getter
    public static Singleton getInstance() {
        return INSTANCE;
    }

    public Connection getConnection() {
        return connection;
    }
}

// Noinstantiable utility class
public class UtilityClass {
    // SUpress default ctor for noninstantiablity
    private UtilityClass() {
        throw new AssertionError();
    }

    // Remainder omitted
}

String s = new String("stringette"); // DON"t DO THIS

String s = "stringette";

Boolean b1 = new Boolean("true"); // Good
Boolean b2 = Boolean.valueOf("true"); // Better!

public class Person {
    private final Date birthDate;
    // Other fields, methods, and constructor omitted
    // DON'T DO THIS!
    public boolean isBabyBoomer() {
        // Unnecessary allocation of expensive object
        Calendar gmtCal=
            Calendar.getInstance(TimeZone.getTimeZone("GMT"));
        gmtCal.set(1946, Calendar.JANUARY, 1, 0, 0, 0);
        Date boomStart = gmtCal.getTime();
        gmtCal.set(1965, Calendar.JANUARY, 1, 0, 0, 0);
        Date boomEnd = gmtCal.getTime();
        return birthDate.compareTo(boomStart) >= 0
            && birthDate.compareTo(boomEnd) < 0;
    }
}

class Person {
    private final Date birthDate;
    // Other fields, methods, and constructor omitted

    /////////////////////////////////////////////////////
    // The starting and ending dates of the baby boom. //
    /////////////////////////////////////////////////////
    private static final Date BOOM_START;
    private static final Date BOOM_END;

    static {
        Calendar gmtCal =
            Calendar.getInstance(TimeZone.getTimeZone("GMT"));
        gmtCal.set(1946, Calendar.JANUARY, 1, 0, 0, 0);
        BOOM_START = gmtCal.getTime();
        gmtCal.set(1965, Calendar.JANUARY, 1, 0, 0, 0);
        BOOM_END = gmtCal.getTime();
    }

    public boolean isBabyBoomer() {
        return birthDate.compareTo(BOOM_START) >= 0
            && birthDate.compareTo(BOOM_END) < 0;
    }
}

// Hideously slow program! Can you spot the object creation?
public static void main(String[] args) {
    Long sum = 0L;
    for (long i = 0; i < Integer.MAX_VALUE; i++) {
        sum += i;
    }
    System.out.printf("sum");
}

// Can you spot the "memory leak"?
public class Stack {
    private Object[] elements;
    private int size = 0;
    private static final int DEFAULT_INITIAL_CAPACITY = 16;

    public Stack() {
        elements = new Object[DEFAULT_INITIAL_CAPACITY];
    }

    public void push(Object e) {
        ensureCapacity();
        elements[size++] = e;
    }

    public Object pop() {
        if (size == 0) {
            throw new EmptyStackException();
        }
        return elements[--size];
    }
    // Ensure space for at least one more element
    // roughly doubling the capacity each time the array
    // needs to grow
    private void ensureCapacity() {
        if (element.length == size) {
            elements = Arrays.copyOf(elements, 2 * size + 1);
        }
    }
}

public Object pop() {
    if (size == 0) {
        throw new EmptyStackException();
    }
    Object result = elements[--size];
    elements[size] = null; // Eliminate obsolete reference
    return result;
}

// try-finally block guarantees execution of termination method
Foo foo = new Foo(...);
try {
    // Do what must be done with foo
    //..
} finally {
    foo.terminate(); // Explicit termination method
}

//Manual finalizer chaining
@Override
protected void finalize() throws Throwable {
    try {
        ... // Finalize subclass state
    } finally {
        super.finalize();
    }
}

public final clas PhoneNumber {
    private final short areaCode;
    private final short prefix;
    private final short lineNumber;

    public PhoneNumber(int areaCode, int prefix,
                       int lineNumber) {
        rangeCheck(areaCode,    999, "area code");
        rangeCheck(prefix,      999, "prefix");
        rangeCheck(lineNumber,  999, "line number");

        this.areaCode = (short) areaCode;
        this.prefix = (short) prefix;
        this.lineNumber = (short) lineNumber;

        private static void rangeCheck(int arg, int max,
                                       String name) {
            if (arg < 0 || arg > max) {
                throw new IllegalArgumentException(name + ": " + arg);
            }
        }

        @Override public boolean equals(Object o) {
            if (o == this) {
                return true;
            }
            if (!(o instanceof PhoneNumber)) {
                return false;
            }
            PhoneNumber pn = (PhoneNumber)o;
            return pn.lineNumber == lineNumber
                && pn.prefix == prefix
                && pn.areaCode == areCode;
        }

        // Broken - no hashCode method!
    }
}

public int hashCode() {
    int h = hash;
    if (h == 0 && value.length > 0) {
        char val[] = value;

        for (int i = 0; i < value.length; i++) {
            h = 31 * h + val[i];
        }
        hash = h;
    }
    return h;
}

package java.lang;

/**
 * A class implements the <code>Cloneable</code> interface to
 * indicate to the {@link java.lang.Object#clone()} method that it
 * is legal for that method to make a
 * field-for-field copy of instances of that class.
 * <p>
 * Invoking Object's clone method on an instance that does not implement the
 * <code>Cloneable</code> interface results in the exception
 * <code>CloneNotSupportedException</code> being thrown.
 * <p>
 * By convention, classes that implement this interface should override
 * <tt>Object.clone</tt> (which is protected) with a public method.
 * See {@link java.lang.Object#clone()} for details on overriding this
 * method.
 * <p>
 * Note that this interface does <i>not</i> contain the <tt>clone</tt> method.
 * Therefore, it is not possible to clone an object merely by virtue of the
 * fact that it implements this interface.  Even if the clone method is invoked
 * reflectively, there is no guarantee that it will succeed.
 *
 * @author  unascribed
 * @see     java.lang.CloneNotSupportedException
 * @see     java.lang.Object#clone()
 * @since   JDK1.0
 */
public interface Cloneable {
}

// cpp implementation can be found here
// http://hg.openjdk.java.net/jdk7/jdk7/hotspot/file/9b0ca45cd756/src/share/vm/prims/jvm.cpp
protected native Object clone() throws CloneNotSupportedException;

// copy ctor
public Yum(Yum yum);
// copy factory
public static Yum newInstance(Yum yum);

public interface Comparable<T> {
    int compareTo(T t);
}

public static <T> void sort(T[] a, Comparator<? super T> c)

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
    //....
}

package org.hfeng.misc.ej2.item12;

import java.util.Arrays;
import java.util.Comparator;

class Player implements Comparable<Player>, Comparator<Player>{
    private int _number;
    private String _name;

    Player(int number, String name) {
        _number = number;
        _name = name;
    }

    Player() {
    }

    public String toString() {
        return String.format("No:%d-Name: %s", _number, _name);
    }

    public int compare(Player p, Player p2) {
        return p._name.compareTo(p2._name);

    }
    public int compareTo(Player p) {
        return this._number - p._number;
    }
}

public class TestOrder {
    public static void main(String[] args) {
        Player[] players = new Player[]{new Player(1, "Allen"),
                new Player(2, "Wade"), new Player(3, "Benson")};
        Arrays.sort(players);
        System.out.println(Arrays.toString(players));
        Arrays.sort(players, new Player());
        System.out.println(Arrays.toString(players));
    }
}

////////////////////////////////////////////////////////////
// <===================OUTPUT===================>         //
// [No:1-Name: Allen, No:2-Name: Wade, No:3-Name: Benson] //
// [No:1-Name: Allen, No:3-Name: Benson, No:2-Name: Wade] //
////////////////////////////////////////////////////////////

// Degenerate classes like this should not be public!
class Point {
    public double x;
    public double y;
}

// Encapsulation of data by accessor methods and mutators
class Point {
    private double x;
    private double y;

    public Point(double x, double y) {
        this.x = x;
        this.y = y;
    }

    public double getX() {
        return x;
    }

    public double getY() {
        return y;
    }

    public void setX(double x) {
        this.x = x;
    }

    public void setY(double y) {
        this.y = y;
    }
}

// Public class with exposed immutable fields - questionable
public final class Time {
    private static final int HOURS_PER_DAY    = 24;
    private static final int MINUTES_PER_HOUR = 60;

    public final int hour;
    public final int minute;
}

BigInteger moby = ...;
moby = moby.flipBit(0);

// Broken - Inappropriate use of inheritance!
public class InstrumentedHashSet<E> extends HashSet<E> {
    // The number of attempted element insertions
    private int addCount = 0;

    public InstrumentedHashSet() {
    }

    public InstrumentedHashSet(int initCap, float loadFactor) {
        super(initCap, loadFactor);
    }

    @Override
    public boolean add(E e) {
        addCount++;
        return super.add(e);
    }

    @Override
    public boolean addAll(Collection<? extends E> c) {
        addCount += c.size();
        return super.addAll(c);
    }

    public int getAddCount() {
        return addCount;
    }
}

package org.hfeng.misc.ej2.item16;

import java.util.Arrays;

public class Test {
    public static void main(String[] args) {
        InstrumentedHashSet<String> s = new InstrumentedHashSet<String>();
        s.addAll(Arrays.asList("Snap", "Crackle", "Pop"));
        System.out.println(s.getAddCount());
    }
}

////////////////////////////////////////////////////
// <===================OUTPUT===================> //
// 6                                              //
////////////////////////////////////////////////////

// Constant interface antipattern - do not use !
public interface PhysicalConstants {
    static final double ELECTRON_MASS = 9.1093;
    static final double BOLTZMANN_CONSTANT = 1.38065;
}

private final Collection<Stamp> stamps = ...;

Set<Lark> exaltation = new HashSet();

Set<Lark> exaltation = new HashSet<Lark>();