Effective Java 3rd edition Chinese English bilingual

Effective-Java-3e-édition-chinois-anglais-bilingue

Il s'agit d'une référence d'apprentissage du chinois et de l'anglais pour chaque chapitre d'Effective Java (3e édition). J'espère qu'elle sera utile pour améliorer la technologie Java. Les suggestions et modifications sont les bienvenues via un problème ou des relations publiques.

Contenu

• Chapitre 2. Création et destruction d'objets
  • Chapitre 2 Introduction
  • Élément 1 : Considérez les méthodes d'usine statiques au lieu des constructeurs (Considérez les méthodes d'usine statiques au lieu des constructeurs)
  • Élément 2 : Considérez un constructeur face à de nombreux paramètres de constructeur
  • Élément 3 : Appliquer la propriété singleton avec un constructeur privé ou un type enum (utilisez un constructeur privé ou un type enum pour implémenter une propriété singleton)
  • Élément 4 : Appliquer la non-instantiabilité avec un constructeur privé (utiliser un constructeur privé pour implémenter la non-instantiabilité)
  • Point 5 : Préférer l'injection de dépendances aux ressources câblées (l'injection de dépendances est meilleure que les ressources câblées)
  • Point 6 : Évitez de créer des objets inutiles
  • Point 7 : Éliminer les références d'objets obsolètes (exclure les références d'objets obsolètes)
  • Article 8 : Éviter les finaliseurs et les nettoyants (éviter d'utiliser des finaliseurs et des nettoyants)
  • Point 9 : Préférez essayer avec des ressources pour essayer enfin (il est préférable d'utiliser essayer avec des ressources plutôt que d'essayer enfin)
• Chapitre 3. Méthodes communes à tous les objets (méthodes communes des objets)
  • Chapitre 3 Introduction
  • Point 10 : Obéir au contrat général lors de la substitution de la méthode égale (la convention qui doit être suivie lors de la substitution de la méthode égale)
  • Élément 11 : Remplacez toujours hashCode lorsque vous remplacez égal (lors du remplacement de la méthode égale, remplacez toujours la méthode hashCode)
  • Élément 12 : Remplacez toujours toString (remplacez toujours la méthode toString)
  • Point 13 : Remplacer judicieusement le clonage (remplacer judicieusement la méthode de clonage)
  • Point 14 : Envisagez d'implémenter Comparable (envisagez d'implémenter l'interface Comparable)
• Chapitre 4. Classes et interfaces
  • Chapitre 4 Introduction
  • Point 15 : Minimiser l'accessibilité des classes et des membres (minimiser l'accessibilité des classes et des membres)
  • Point 16 : Dans les classes publiques, utilisez des méthodes d'accès et non des champs publics (dans les classes publiques, utilisez des méthodes d'accès et non des champs publics)
  • Point 17 : Minimiser la mutabilité (réduire la variabilité)
  • Point 18 : Privilégier le concordat à l'héritage
  • Point 19 : Conception et document pour l'héritage ou bien l'interdire (l'héritage doit être bien conçu et documenté, sinon son utilisation est interdite)
  • Item 20 : Préférer les interfaces aux classes abstraites (Les interfaces sont meilleures que les classes abstraites)
  • Point 21 : Concevoir des interfaces pour la postérité
  • Élément 22 : Utiliser les interfaces uniquement pour définir les types (les interfaces ne sont utilisées que pour définir les types)
  • Point 23 : Préférer les hiérarchies de classes aux classes balisées (les hiérarchies de classes sont meilleures que les classes balisées)
  • Point 24 : Privilégiez les classes membres statiques par rapport aux classes membres non statiques (les classes membres statiques sont meilleures que les classes membres non statiques)
  • Élément 25 : Limiter les fichiers source à une seule classe de niveau supérieur (les fichiers sources sont limités à une seule classe de niveau supérieur)
• Chapitre 5. Génériques
  • Chapitre 5Introduction
  • Article 26 : Ne pas utiliser de types bruts (N'utilisez pas de types bruts)
  • Point 27 : Éliminer les avertissements non vérifiés (éliminer les avertissements non vérifiés)
  • Article 28 : Préférer les listes aux tableaux (la liste vaut mieux que le tableau)
  • Item 29 : Privilégier les types génériques (préférer utiliser les types génériques)
  • Item 30 : Privilégier les méthodes génériques (préférer utiliser les méthodes génériques)
  • Élément 31 : Utilisez des caractères génériques limités pour augmenter la flexibilité de l'API (utilisez des caractères génériques limités pour augmenter la flexibilité de l'API)
  • Item 32 : Combiner judicieusement les génériques et les varargs
  • Point 33 : Considérez les conteneurs hétérogènes de type sécurisé (Considérez les conteneurs hétérogènes de type sécurisé)
• Chapitre 6. Énumérations et annotations (énumérations et annotations)
  • Chapitre 6 Introduction
  • Élément 34 : utilisez des énumérations au lieu de constantes int (utilisez des types d'énumération au lieu de constantes int)
  • Élément 35 : Utiliser des champs d'instance au lieu d'ordinaux
  • Élément 36 : Utilisez EnumSet au lieu des champs de bits (utilisez EnumSet au lieu des champs de bits)
  • Élément 37 : Utilisez EnumMap au lieu de l'indexation ordinale (Utilisez EnumMap pour remplacer l'indexation ordinale)
  • Point 38 : Émuler des énumérations extensibles avec des interfaces (utiliser des interfaces pour simuler des énumérations extensibles)
  • Item 39 : Préférer les annotations aux modèles de nommage (les annotations sont meilleures que les modèles de nommage)
  • Élément 40 : Utilisez systématiquement l'annotation Override (insistez pour utiliser l'annotation @Override)
  • Élément 41 : Utiliser les interfaces de marqueurs pour définir les types
• Chapitre 7. Lambdas et flux (expressions λ et flux)
  • Chapitre 7 Introduction
  • Item 42 : Préférer les lambdas aux classes anonymes (les expressions λ sont meilleures que les classes anonymes)
  • Point 43 : Préférer les références de méthode aux lambdas (les références de méthode sont meilleures que les expressions lambda)
  • Point 44 : Favoriser l'utilisation d'interfaces fonctionnelles standards
  • Point 45 : Utiliser les flux à bon escient
  • Point 46 : Préférer les fonctions sans effets secondaires dans les flux (utiliser les fonctions sans effets secondaires dans les flux)
  • Élément 47 : Préférer Collection à Stream comme type de retour (Préférer Collection au lieu de stream comme type de retour)
  • Point 48 : Soyez prudent lorsque vous rendez des flux parallèles
• Chapitre 8. Méthodes
  • Chapitre 8 Introduction
  • Point 49 : Vérifier la validité des paramètres
  • Point 50 : Faire des copies défensives si nécessaire
  • Point 51 : Concevoir soigneusement les signatures de méthode (concevoir soigneusement les signatures de méthode)
  • Point 52 : Utiliser judicieusement la surcharge
  • Objet 53 : Utiliser les varargs judicieusement
  • Élément 54 : renvoie des collections ou des tableaux vides, non nuls (renvoie des collections ou des tableaux vides, non nuls)
  • Article 55 : Retourner les options judicieusement
  • Point 56 : Rédiger des commentaires sur la documentation pour tous les éléments d'API exposés
• Chapitre 9. Programmation générale
  • Chapitre 9 Introduction
  • Article 57 : Réduire la portée des variables locales (minimiser la portée des variables locales)
  • Article 58 : Préférer les boucles for-each aux boucles for traditionnelles (la boucle for-each est meilleure que la boucle for traditionnelle)
  • Item 59 : Connaître et utiliser les bibliothèques
  • Point 60 : Évitez les types float et double si des réponses exactes sont requises (les types float et double doivent être évités si des réponses exactes sont requises)
  • Article 61 : Préférer les types primitifs aux primitives en boîte (les types de données de base sont meilleurs que les classes wrapper)
  • Point 62 : Évitez les chaînes là où d'autres types sont plus appropriés (évitez d'utiliser des chaînes lorsque d'autres types sont plus appropriés)
  • Point 63 : Méfiez-vous des performances de la concaténation de chaînes (méfiez-vous des problèmes de performances causés par la concaténation de chaînes)
  • Item 64 : Faire référence aux objets par leurs interfaces
  • Item 65 : Préférer les interfaces à la réflexion (L'interface vaut mieux que la réflexion)
  • Point 66 : Utiliser judicieusement les méthodes natives
  • Point 67 : Optimiser judicieusement
  • Point 68 : Adhérer aux conventions de dénomination généralement acceptées
• Chapitre 10. Exceptions
  • Chapitre 10 Introduction
  • Article 69 : Utiliser les exceptions uniquement pour des conditions exceptionnelles
  • Élément 70 : Utiliser les exceptions vérifiées pour les conditions récupérables et les exceptions d'exécution pour les erreurs de programmation (utiliser les exceptions vérifiées pour les conditions récupérables et les exceptions d'exécution pour les erreurs de programmation)
  • Point 71 : Éviter l'utilisation inutile des exceptions vérifiées (Éviter l'utilisation inutile des exceptions vérifiées)
  • Point 72 : Favoriser le recours aux exceptions standards (encourager la réutilisation des exceptions standards)
  • Point 73 : lancer des exceptions appropriées à l'abstraction (lancer des exceptions qui peuvent être expliquées par l'abstraction)
  • Élément 74 : Documentez toutes les exceptions levées par chaque méthode (enregistrez toutes les exceptions levées par chaque méthode)
  • Élément 75 : Inclure les informations de capture d'échec dans les messages détaillés (les messages détaillés d'exception doivent inclure des informations sur l'échec de capture)
  • Point 76 : Efforcez-vous d'atteindre l'atomicité de l'échec (faites de votre mieux pour garantir l'atomicité de l'échec)
  • Point 77 : N'ignorez pas les exceptions
• Chapitre 11. Concurrence
  • Chapitre 11 Introduction
  • Article 78 : Synchroniser l'accès aux données mutables partagées
  • Article 79 : Éviter une synchronisation excessive
  • Élément 80 : Préférer les exécuteurs, les tâches et les flux aux threads (les exécuteurs, les tâches et les flux sont meilleurs que l'utilisation directe des threads)
  • Point 81 : Préférer les utilitaires de concurrence pour attendre et notifier (les utilitaires de concurrence sont meilleurs que d'attendre et de notifier)
  • Élément 82 : Documenter la sécurité des threads (le document doit contenir des attributs de sécurité des threads)
  • Élément 83 : Utiliser judicieusement l’initialisation paresseuse
  • Point 84 : Ne dépendez pas du planificateur de threads (Ne comptez pas sur le planificateur de threads)
• Chapitre 12. Sérialisation
  • Chapitre 12 Introduction
  • Item 85 : Préférer les alternatives à la sérialisation Java (préférer les alternatives à la sérialisation Java)
  • Point 86 : implémentez Serialisable avec une grande prudence
  • Élément 87 : Envisagez d'utiliser un formulaire sérialisé personnalisé (envisagez d'utiliser un formulaire sérialisé personnalisé)
  • Élément 88 : Écrire les méthodes readObject de manière défensive (écrire les méthodes readObject de manière défensive)
  • Élément 89 : Pour le contrôle d'instance, préférez les types enum à readResolve (Pour le contrôle d'instance, les types enum sont meilleurs que readResolve)
  • Point 90 : Envisagez des proxys de sérialisation au lieu d'instances sérialisées (envisagez des proxys de sérialisation au lieu d'instances sérialisées)