Notas de estudio de Effective Java (segunda edición)

Capítulo 2 Creación y destrucción de objetos

Elemento 1: considere métodos de fábrica estáticos en lugar de constructores

Elemento 2: considere un constructor cuando se enfrente a muchos parámetros de constructor

Puede consultar este artículo: Use Builder para resolver el problema de demasiados parámetros de constructor

Elemento 3: hacer cumplir la propiedad singleton con un constructor privado o un tipo de enumeración

Puede consultar este artículo: Java Design Pattern-Singleton Pattern

Ítem 4: Hacer cumplir la no instanciabilidad con un constructor privado

Ítem 5: Evite la creación de objetos innecesarios.

String s = new String("abcdefg");   //bad

String s = "abcdefg";               //good

Elemento 6: eliminar referencias de objetos obsoletos

Cuando la referencia ya no sea necesaria, asígnela a null

public Object pop(){
    if(size == 0){
        throw new EmptyStackException();
    }
    Object result = elments[--size];
    elements[size] = null;   //删除不再需要的引用
    return result;
}

Elemento 7: Evite los finalizadores

Capítulo 3 Métodos comunes a todos los objetos

Ítem 8: Obedezca el contrato general al anular `equals`

Si x, y y z son referencias no nulas:
1. Reflexivo : x.equals (x) debe devolver verdadero
2. Simétrico : x.equals (y) devuelve verdadero si y solo si y.equals (x) devuelve a verdadero
3. transitivo, (transitivo): x.equals (y) devuelve verdadero, e y.equals (z) devuelve verdadero, luego x.equals (z) regresa a verdadero
4. lo consistente (consistente): Después de llamar a x .equals (y) varias veces, todas devuelven verdadero o todas devuelven falso

Elemento 9: anular siempre `hashCode`cuando anule`equals`

Item10: Anular siempre `toString`

Ítem 11: Anular `clone`juiciosamente

Copiar constructor:

public Yum(Yum yum);

Copiar método de fábrica:

public static Yum newInstance(Yum yum);

Ítem 12: Considere implementar `Comparable`

Para comparar los tipos básicos, use "<" y ">".
Para los tipos float y double, use Float.compare y Double.compare

Capítulo 4 Clases e interfaces

Ítem 13: Minimizar la accesibilidad de clases y miembros

Accesibilidad de menor a mayor:
private-> default-> protected->public

La accesibilidad del método en la subclase debe ser mayor o igual que overrideel método cubierto por la clase principal ( )
Si una clase implementa una interfaz, el método con el mismo nombre en la interfaz debe serpublic

Ítem 14: En clases públicas, use métodos de acceso, no campos públicos

métodos de acceso: getters
mutadores:setters

Ítem 15: Minimizar la mutabilidad

En la operación de varios pasos (como en un bucle), reemplace el tipo inmutable con un tipo variable , que puede mejorar el rendimiento. Por ejemplo, en el bucle, reemplace con
forStringBuilderString

Ítem 16: Favorecer la composición sobre la herencia

Ítem 17: Diseñar y documentar para herencia o prohibirlo

Ítem 18: Preferir interfaces a clases abstractas

Elemento 19: Utilice interfaces solo para definir tipos

Elemento 20: Prefiera las jerarquías de clases a las clases etiquetadas

Ítem 21: Usa objetos de función para representar estrategias.

Ítem 22: Favorecer las clases de miembros estáticas sobre las no estáticas

Las instancias de clase interna no estáticas deben ser creadas por instancias externas

Capítulo 5 Genéricos

Elemento 23: No utilice el tipo sin formato en el código nuevo

Utilice List <E> en lugar de List.
List <String> es una subclase de List, pero no una subclase de List <Object>.

Ítem 24: Elimina las advertencias no marcadas

Ítem 25: Preferir listas a matrices

Array es un tipo covariante. Si Sub es un subtipo de Super, entonces Sub [] también es un subtipo de Super [].
Generics es un tipo no covariante y List <Type1> gen Listt <Type2> no tiene nada que ver con eso.

    Object[] objectArray = new Long[1];
    objectArray[0] = "abc";                   //运行时才报错

    List<Object> ol = new ArrayList<long>();  //编译时就报错
    ol.add("abc");

Ítem 26: Favorecer los tipos genéricos

Ítem 27: Favorecer los métodos genéricos

Si el tipo de retorno de la función es genérico , debe agregar <E> entre el modificador de función y el tipo de retorno :

public static <E> Set<E> union(){
    Set<E> set = new HashSet<E>();
    ...
    return set;
}

Elemento 28: Utilice comodines delimitados para aumentar la flexibilidad de la API

public void pushAll(Iterable<? extends E> src){
    ...
}

public void popAll(Collection<? super E> des){
    ...
}

Tanto <? Extiende E> y <? Super E> comodines están delimitadas, se extiende se utiliza para especificar el límite superior , y super se utiliza para especificar el límite inferior .

Dos pautas:

PECS: Productor (productor) usa extensiones, consumidor (consumidor) usa super
Todos los comparables y comparadores son consumidores

Ítem 29: Considere contenedores heterogéneos de seguridad tipográfica

String.classLo genérico es Class<String>
Integer.classlo genérico esClass<Integer>

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

Capítulo 6 Enums y anotaciones

Item 30: Use enums instead of `int` constants

Item 31: Use instance fields instead of ordinals

Item 32: Use `EnumSet` instead of bit fields

Item 33: Use `EnumMap` instead of ordinal indexing

Item 34: Emulate extensible enums with interfaces

Item 35: Prefer annotations to naming patterns

Item 36: Consistently use the `Override` annotation

Item 37: Use marker interfaces to define types

Chapter 7 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

在overload方法中做选择是静态的，在override方法中做选择是动态的。

Item 42: Use varargs judiciously

Item 43: Return empty arrays or collections, not nulls

Item 44: Write doc comments for all exposed API elements

Chapter 8 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

float和double的结果是准确近似，并不精确。
如果需要精确的结果，应该使用BigDecimal、int或long

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

如果改动次数较多，应该使用StringBuilder

Item 52: Refer to objects by their interfaces

Item 53: Prefer interfaces to reflection

Item 54: Use native methods judiciously

Item 55: Optimize judiciously

Strive to write good programs rather than fast ones.

Item 56: Adhere to generally accepted naming conventions

Chapter 9 Exceptions

Item 57: Use exceptions only for exceptional conditions

Item 58: Use checked exceptions for reconverable conditions and runtimeexceptions for programming errors

三种throwable：

checked exceptions
runtime exceptions
errors

调用者如果能恢复，应该使用checked exceptions
用runtime exceptions来提示编程错误

Item 59: Avoid unneccessary use of checked exceptions

Item 60: Favor the use of standard exceptions

Item 61: Throw exceptions appropriate to the abstraction

Item 62: Document all exceptions thrown by each method

Item 63: Include failure-capture information in detail messages

Item 64: Strive for failure atomicity

Item 65: Don’t ignore exceptions

Chapter 10 Concurrency

Item 66: Synchronize access to shared mutable data

Item 67: Avoid excessive synchronization

Item 68: Prefer executors and tasks to threads

Item 69: Prefer concurrency utilities to `wait` and `notify`

Ítem 70: Seguridad del hilo del documento

Ítem 71: Use la inicialización perezosa con prudencia

Ítem 72: No dependa del programador de subprocesos

Ítem 73: Evite los grupos de hilos

Capítulo 11 Serialización

Ítem 74: Implementar `Serializable`juiciosamente

La deserialización es un constructor implícito.

Finalización eficaz de los puntos de conocimiento de Java