Creating and Destroying Objects
Methods Common to All Objects
Classes and Interfaces
Generics
Enums and Annotations
Methods
General Programming
Exceptions
Concurrency
Serialization

This item list come for Effective Java Second Edition

Creating and Destroying Objects

Item 1: Consider static factory methods instead of constructors

Item 2: Consider a builder when faced with many constructor parameters

Item 3: Enforce the singleton property with a private constructor or an enum type

Item 4: Enforce noninstantiability with a private constructor

Item 5: Avoid creating unnecessary objects

Item 6: Eliminate obsolete object references

Item 7: Avoid finalizers

Methods Common to All Objects

Item 8: Obey the general contract when overriding equals

Item 9: Always override hashCode when you override equals

Item 10: Always override toString

Item 11: Override clone judiciously

Item 12: Consider implementing Comparable

Classes and Interfaces

Item 13: Minimize the accessibility of classes and members

Item 14: In public classes, use accessor methods, not public fields

Item 15: Minimize mutability

Item 16: Favor composition over inheritance

Item 17: Design and document for inheritance or else prohibit it

Item 18: Prefer interfaces to abstract classes

Item 19: Use interfaces only to define types

Item 20: Prefer class hierarchies to tagged classes

Item 21: Use function objects to represent strategies

Item 22: Favor static member classes over nonstatic

除非member classes有存取到outter class的nonstatic method，不然，應該把member classes宣告為statics

Generics

Item 23: Don’t use raw types in new code

Item 24: Eliminate unchecked warnings

Item 25: Prefer lists to arrays

Item 26: Favor generic types

Item 27: Favor generic methods

    // Generic method
    public static <E>Set<E>union(Set<E>s1, Set<E>s2) {
        Set<E>result = new HashSet<E>(s1);
        result.addAll(s2);
        return result;
    }

Item 28: Use bounded wildcards to increase API flexibility

Item 29: Consider typesafe heterogeneous containers

利用加上Class<T>來確定T的型別

    // Typesafe heterogeneous container pattern - API
    public class Favorites {
    public <T> void putFavorite(Class<T> type, T instance);
    public <T> T getFavorite(Class<T> type);
    }

Enums and Annotations

Item 30: Use enums instead of int constants

Item 31: Use instance fields instead of ordinals

Item 32: Use EnumSet instead of bit fields

如果要用位元開關的效果，可以考慮用EnumSet

Item 33: Use EnumMap instead of ordinal indexing

如果需要對Enum進行排序，可以用EnumMap

Item 34: Emulate extensible enums with interfaces

Enum是無法繼承的，如果需要類似的功能，可以考慮用interfaces

    // Emulated extensible enum using an interface
    public interface Operation {
        double apply(double x, double y);
    }
     
    public enum BasicOperation implements Operation {
        PLUS("+") {
            public double apply(double x, double y) {
                return x + y;
            }
        },
        MINUS("-") {
            public double apply(double x, double y) {
                return x - y;
            }
        },
        TIMES("*") {
            public double apply(double x, double y) {
                return x * y;
            }
        },
        DIVIDE("/") {
            public double apply(double x, double y) {
                return x / y;
            }
     
            private final String  symbol;
     
            BasicOperation(String symbol) {
                this.symbol = symbol;
            }
     
            @Override
            public String toString() {
                return symbol;
            }
        }
    };
     
    // Emulated extension enum
    public enum ExtendedOperation implements Operation {
        EXP("^") {
            public double apply(double x, double y) {
                return Math.pow(x, y);
            }
        },
        REMAINDER("%") {
            public double apply(double x, double y) {
                return x % y;
            }
        };
        private final String  symbol;
     
        ExtendedOperation(String symbol) {
            this.symbol = symbol;
        }
     
        @Override
        public String toString() {
            return symbol;
        }
    }

Item 35: Prefer annotations to naming patterns

只要想到要用method name的rule做判斷邏輯時，可以考慮用annotations或許會更彈性

Item 36: Consistently use the Override annotation

Item 37: Use marker interfaces to define types

Methods

Item 38: Check parameters for validity

Item 39: Make defensive copies when needed

Item 40: Design method signatures carefully

Item 41: Use overloading judiciously

Item 42: Use varargs judiciously

Item 43: Return empty arrays or collections, not nulls

Item 44: Write doc comments for all exposed API elements

General Programming

Item 45: Minimize the scope of local variables

Item 46: Prefer for-each loops to traditional for loops

Item 47: Know and use the libraries

Item 48: Avoid float and double if exact answers are required

Item 49: Prefer primitive types to boxed primitives

Item 50: Avoid strings where other types are more appropriate

Item 51: Beware the performance of string concatenation

Item 52: Refer to objects by their interfaces

Item 53: Prefer interfaces to reflection

Item 54: Use native methods judiciously

Item 55: Optimize judiciously

Item 56: Adhere to generally accepted naming conventions

Exceptions

Item 57: Use exceptions only for exceptional conditions

Item 58: Use checked exceptions for recoverable conditions and runtime exceptions for programming errors

checked exceptions應該是來被rescue的，只有能被復原的狀況，才用check exception

Table of contents