Efectivo-Java-3ra-edición-chino-inglés-bilingüe
Esta es una referencia de aprendizaje de chino e inglés para cada capítulo de Effective Java (tercera edición). Espero que sea útil para mejorar la tecnología Java. Se aceptan sugerencias y modificaciones a través de ediciones o relaciones públicas.
Contenido
- Capítulo 2. Creación y destrucción de objetos
- Capítulo 2 Introducción
- Elemento 1: considere métodos de fábrica estáticos en lugar de constructores (considere métodos de fábrica estáticos en lugar de constructores)
- Elemento 2: Considere un constructor cuando se enfrenta a muchos parámetros de constructor
- Elemento 3: hacer cumplir la propiedad singleton con un constructor privado o un tipo de enumeración (use un constructor privado o un tipo de enumeración para implementar una propiedad singleton)
- Elemento 4: Aplicar la no instanciabilidad con un constructor privado (use un constructor privado para implementar la no instanciabilidad)
- Ítem 5: Prefiera la inyección de dependencia a los recursos cableados (la inyección de dependencia es mejor que los recursos cableados)
- Punto 6: Evite crear objetos innecesarios
- Tema 7: Eliminar referencias a objetos obsoletos (excluir referencias a objetos obsoletos)
- Ítem 8: Evite finalizadores y limpiadores (evite el uso de finalizadores y limpiadores)
- Ítem 9: Prefiero probar con recursos que probar finalmente (usar probar con recursos es mejor que probar finalmente)
- Capítulo 3. Métodos comunes a todos los objetos (métodos comunes de objetos)
- Capítulo 3 Introducción
- Ítem 10: Obedecer el contrato general al anular iguales (la convención que se debe seguir al anular el método igual)
- Elemento 11: siempre anule hashCode cuando anule iguales (al anular el método igual, siempre anule el método hashCode)
- Elemento 12: Anular siempre toString (anular siempre el método toString)
- Ítem 13: Anular la clonación con criterio (anular el método de clonación con prudencia)
- Punto 14: Considere implementar Comparable (Considere implementar la interfaz Comparable)
- Capítulo 4. Clases e Interfaces
- Capítulo 4 Introducción
- Ítem 15: Minimizar la accesibilidad de clases y miembros (minimizar la accesibilidad de clases y miembros)
- Ítem 16: En clases públicas, use métodos de acceso, no campos públicos (en clases públicas, use métodos de acceso, no campos públicos)
- Ítem 17: Minimizar la mutabilidad (reducir la variabilidad)
- Tema 18: Favorecer la composición sobre la herencia
- Punto 19: Diseño y documento para la herencia o en caso contrario prohibirla (la herencia debe estar bien diseñada y documentada, en caso contrario se prohíbe su uso)
- Ítem 20: Prefiero interfaces a clases abstractas (las interfaces son mejores que las clases abstractas)
- Tema 21: Diseño de interfaces para la posteridad
- Ítem 22: Use interfaces solo para definir tipos (las interfaces solo se usan para definir tipos)
- Ítem 23: Prefiera jerarquías de clases a clases etiquetadas (las jerarquías de clases son mejores que las clases etiquetadas)
- Punto 24: Favorecer las clases de miembros estáticos sobre las no estáticas (las clases de miembros estáticos son mejores que las clases de miembros no estáticos)
- Elemento 25: Limitar los archivos fuente a una única clase de nivel superior (los archivos fuente están limitados a una única clase de nivel superior)
- Capítulo 5. Genéricos
- Capítulo 5 Introducción
- Ítem 26: No utilice tipos sin formato (No utilice tipos sin formato)
- Ítem 27: Eliminar advertencias no marcadas (eliminar advertencias no marcadas)
- Ítem 28: Prefiera listas a matrices (la lista es mejor que la matriz)
- Ítem 29: Favorecer los tipos genéricos (prefiero usar tipos genéricos)
- Ítem 30: Favorecer los métodos genéricos (prefieren usar métodos genéricos)
- Ítem 31: Utilice comodines limitados para aumentar la flexibilidad de la API (use comodines limitados para aumentar la flexibilidad de la API)
- Ítem 32: Combine juiciosamente genéricos y varargs
- Ítem 33: Considere contenedores heterogéneos con seguridad de tipos (Considere contenedores heterogéneos con seguridad de tipos)
- Capítulo 6. Enumeraciones y anotaciones (enumeraciones y anotaciones)
- Capítulo 6 Introducción
- Ítem 34: Use enumeraciones en lugar de constantes int (use tipos de enumeración en lugar de constantes int)
- Ítem 35: Utilice campos de instancia en lugar de ordinales
- Elemento 36: use EnumSet en lugar de campos de bits (use EnumSet en lugar de campos de bits)
- Elemento 37: use EnumMap en lugar de la indexación ordinal (use EnumMap para reemplazar la indexación ordinal)
- Ítem 38: Emular enumeraciones extensibles con interfaces (use interfaces para simular enumeraciones extensibles)
- Ítem 39: Prefiera las anotaciones a los patrones de nombres (las anotaciones son mejores que los patrones de nombres)
- Ítem 40: Utilice consistentemente la anotación Override (insista en usar la anotación @Override)
- Artículo 41: Utilice interfaces de marcador para definir tipos
- Capítulo 7. Lambdas y Streams (λ expresiones y streams)
- Capítulo 7 Introducción
- Ítem 42: Prefiera lambdas a las clases anónimas (las expresiones λ son mejores que las clases anónimas)
- Ítem 43: Prefiera las referencias a métodos a las lambdas (las referencias a métodos son mejores que las expresiones lambda)
- Punto 44: Favorecer el uso de interfaces funcionales estándar
- Ítem 45: Utilice las transmisiones con prudencia
- Ítem 46: Preferir funciones libres de efectos secundarios en transmisiones (use funciones libres de efectos secundarios en transmisiones)
- Ítem 47: Prefiera Colección a Transmisión como tipo de devolución (Prefiera Colección en lugar de transmisión como tipo de devolución)
- Ítem 48: Tenga cuidado al hacer corrientes paralelas
- Capítulo 8. Métodos
- Capítulo 8 Introducción
- Ítem 49: Verificar la validez de los parámetros
- Artículo 50: Hacer copias defensivas cuando sea necesario
- Ítem 51: Firmas de métodos de diseño cuidadoso (firmas de métodos de diseño cuidadoso)
- Ítem 52: Utilice la sobrecarga con prudencia
- Ítem 53: Utilice varargs con prudencia
- Ítem 54: Devuelve colecciones o matrices vacías, no nulas (devuelve colecciones o matrices vacías, no nulas)
- Artículo 55: Devolver los opcionales con criterio
- Elemento 56: Escriba comentarios de documentos para todos los elementos API expuestos
- Capítulo 9. Programación general
- Capítulo 9 Introducción
- Ítem 57: Minimizar el alcance de las variables locales (minimizar el alcance de las variables locales)
- Ítem 58: Prefiera los bucles for each a los bucles for tradicionales (el bucle for each es mejor que el bucle for tradicional)
- Tema 59: Conocer y utilizar las bibliotecas
- Ítem 60: Evite los tipos flotante y doble si se requieren respuestas exactas (deben evitarse los tipos flotante y doble si se requieren respuestas exactas)
- Ítem 61: Prefiera los tipos primitivos a los primitivos en caja (los tipos de datos básicos son mejores que las clases contenedoras)
- Ítem 62: Evite cadenas donde otros tipos sean más apropiados (evite usar cadenas cuando otros tipos sean más apropiados)
- Ítem 63: Tenga cuidado con el rendimiento de la concatenación de cadenas (tenga cuidado con los problemas de rendimiento causados por la concatenación de cadenas)
- Ítem 64: Hacer referencia a los objetos por sus interfaces.
- Ítem 65: Prefiero las interfaces a la reflexión (la interfaz es mejor que la reflexión)
- Ítem 66: Utilice métodos nativos con prudencia
- Ítem 67: Optimizar juiciosamente
- Artículo 68: Adherirse a las convenciones de nomenclatura generalmente aceptadas.
- Capítulo 10. Excepciones
- Capítulo 10 Introducción
- Artículo 69: Utilizar excepciones sólo para condiciones excepcionales
- Ítem 70: Utilice excepciones marcadas para condiciones recuperables y excepciones de tiempo de ejecución para errores de programación (use excepciones marcadas para condiciones recuperables y excepciones de tiempo de ejecución para errores de programación)
- Ítem 71: Evitar el uso innecesario de excepciones marcadas (Evitar el uso innecesario de excepciones marcadas)
- Tema 72: Favorecer el uso de excepciones estándar (fomentar la reutilización de excepciones estándar)
- Ítem 73: Lanzar excepciones apropiadas para la abstracción (arrojar excepciones que puedan explicarse mediante abstracción)
- Ítem 74: Documentar todas las excepciones lanzadas por cada método (registrar todas las excepciones lanzadas por cada método)
- Ítem 75: Incluir información de captura de fallas en mensajes detallados (los mensajes detallados de excepción deben incluir información de captura de fallas)
- Ítem 76: Esfuércese por lograr la atomicidad del fracaso (haga todo lo posible para garantizar la atomicidad del fracaso)
- Artículo 77: No ignores las excepciones
- Capítulo 11. Concurrencia
- Capítulo 11 Introducción
- Ítem 78: Sincronizar el acceso a datos mutables compartidos
- Ítem 79: Evite la sincronización excesiva
- Ítem 80: Prefiera ejecutores, tareas y transmisiones a subprocesos (los ejecutores, tareas y transmisiones son mejores que usar subprocesos directamente)
- Ítem 81: Prefiero que las utilidades de concurrencia esperen y notifiquen (las utilidades de concurrencia son mejores que esperar y notificar)
- Ítem 82: Seguridad del hilo del documento (el documento debe contener atributos de seguridad del hilo)
- Ítem 83: Utilice la inicialización diferida con prudencia
- Ítem 84: No dependa del programador de subprocesos (No dependa del programador de subprocesos)
- Capítulo 12. Serialización
- Capítulo 12 Introducción
- Ítem 85: Prefiero alternativas a la serialización de Java (prefiero alternativas a la serialización de Java)
- Ítem 86: Implementar Serializable con mucha precaución
- Ítem 87: Considere usar un formulario serializado personalizado (Considere usar un formulario serializado personalizado)
- Ítem 88: Escriba métodos readObject de manera defensiva (escriba métodos readObject de manera defensiva)
- Ítem 89: Por ejemplo, control, prefiera los tipos de enumeración a readResolve (por ejemplo, control, los tipos de enumeración son mejores que readResolve)
- Ítem 90: Considere proxies de serialización en lugar de instancias serializadas (Considere proxies de serialización en lugar de instancias serializadas)
