Effective Java 3rd Edition Chapitre 2 Création et disparition d'objets

[Effective Java 3rd Edition](https://www.amazon.co.jp/Effective-Java-%E7%AC%AC3%E7%89%88-%E3%], qui est un livre indispensable pour les utilisateurs Java intermédiaires et supérieurs. 82% B8% E3% 83% A7% E3% 82% B7% E3% 83% A5% E3% 82% A2% E3% 83% BB% E3% 83% 96% E3% 83% AD% E3% 83% 83% E3% 82% AF-ebook / dp / B07RHX1K53) a une version Kindle, donc je vais le résumer. "Chapitre 1 Introduction" est principalement une explication des termes, donc je vais l'ignorer.

Précédent: Aucun Suivant: Méthodes efficaces de Java 3rd Edition Chapitre 3 communes à tous les objets

Élément 1 Considérez une méthode de fabrique statique au lieu d'un constructeur

• La méthode de fabrique statique est quelque chose comme Boolean.valueOf (boolean b).

[Good]exemple de méthode de fabrique statique

public static Boolean valueOf(boolean b) {
  return b ? Boolean.True : Boolean.False
}

• Avantages de la méthode d'usine statique
• Contrairement aux constructeurs, il a un nom.
• Puisque le constructeur n'a pas de nom, il est difficile de juger la fonction par le paramètre.
• Contrairement aux constructeurs, vous n'avez pas besoin de créer un nouvel objet pour chaque appel.
• Évitez la création d'objets dupliqués inutiles.
• Contrairement aux constructeurs, il peut renvoyer des objets de n'importe quel sous-type du type de retour de la méthode.
• La classe de l'objet retourné est modifiée pour chaque appel en fonction de la valeur du paramètre d'entrée.
• La classe de l'objet retourné ne doit pas nécessairement exister au moment où la classe contenant sa méthode de fabrique statique a été écrite.
• Contraintes de méthode d'usine statique
• Impossible de créer des sous-classes de classes qui n'ont pas de constructeurs publics ou protégés
• Par exemple, vous ne pouvez pas créer une sous-classe de l'une des classes d'implémentation de l'utilitaire dans la structure de collecte.
• Vous devez utiliser la composition, pas l'héritage.
• Il est difficile pour le programmeur de trouver la méthode de fabrique statique.
• Convention de dénomination des méthodes de fabrique statique
  • from
  • of
  • valueOf
  • instance or getInstance
  • create or newInstance
  • getType
  • newType
  • type

Point 2 Considérez un constructeur face à de nombreux paramètres de constructeur

[Good]Exemple de classe Builder

public class NutritionFacts {
    private final int savingSize;
    private final int savings;
    private final int calories;
    private final int fat;
    private final int sodium;
    private final int carbohydrate;

    public static class Builder {
        //Obligatoire
        private final int savingSize;
        private final int savings;

        //Valeur par défaut facultative
        private int calories = 0;
        private int fat = 0;
        private int sodium = 0;
        private int carbohydrate = 0;

        public Builder(int savingSize, int savings) {
            this.savingSize = savingSize;
            this.savings = savings;
        }

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

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

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

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

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

    }

    private NutritionFacts(Builder builder) {
        savingSize = builder.savingSize;
        savings = builder.savings;
        calories = builder.calories;
        fat = builder.fat;
        sodium = builder.sodium;
        carbohydrate = builder.carbohydrate;
    }
}

Exemple d'utilisation de lombok @ Builder

Exemple d'utilisation de lombok

import lombok.Builder;
import lombok.NonNull;

@Builder
public class LombokNutritionFacts {

    //Obligatoire
    @NonNull
    private final Integer savingSize;
    @NonNull
    private final Integer savings;

    //Définition de la valeur par défaut
    @Builder.Default
    private final Integer calories = 0;
    @Builder.Default
    private final Integer fat = 0;
    @Builder.Default
    private final Integer sodium = 0;
    @Builder.Default
    private final Integer carbohydrate = 0;
}

Élément 3 Appliquer les caractéristiques de singleton avec un constructeur privé ou un type enum

[Good]Classe singleton utilisant le type enum

//Classe singleton utilisant le type enum
public enum Elvis {
    INSTANCE;

    public void leaveTheBilding() {
        System.out.println("Hello Elvis!");
    }
}

//Exemple d'appel
public class Main {
    public static void main(String[] args){
        Elvis elvis = Elvis.INSTANCE;
        elvis.leaveTheBilding();
    }
}

Item 4 Forcer l'impossibilité d'instanciation avec un constructeur privé

[Good]

//Classes d'utilité qui ne peuvent pas être instanciées
public class UtilityClass {
    //Créer un constructeur privé afin qu'il ne puisse pas être instancié
    private UtilityClass() {
        throw new AssertionError();  //Lancer si appelé en classe
    }
    //Omis ci-dessous
}

Élément 5 Sélectionnez l'injection de dépendances plutôt que de lier directement les ressources

[Bad]

//Mauvaise utilisation des utilitaires statiques. Il manque de flexibilité et ne peut pas être testé.
public class SpellCheckerStatic {
    private static final Lexicon dictionary = new MyDictionary();

    private SpellCheckerStatic() {
    }
    public static boolean isValid(String word) {
        //réduction
    }
    public static List<String> suggestions(String type) {
        //réduction
    }
}

[Good]

//L'injection de dépendance est flexible et testable
public class SpellChecker {
    private final Lexicon dictionary;

    public SpellChecker(Lexicon dictionary) {
        this.dictionary = Objects.requireNonNull(dictionary);
    }
    public boolean isValid(String word) {
        //réduction
    }
    public List<String> suggestions(String type) {
        //réduction
    }
}

Élément 6 Évitez de créer des objets inutiles

//Cela crée des objets inutiles, donc
String s = new String("bikini");
//Devrait faire ça
String s = "bikini";

• Vous devez utiliser des méthodes de fabrique statiques plutôt que des constructeurs. --Choisissez un type de données de base sur un type de données de base encadré et faites attention aux boîtes automatiques involontaires.

public class RomanNumerals {
    private static final Pattern ROMAN = Pattern.compile(
            "^(?=.)M*(C[MD]|D?C{0,3})" +
                    "(X[CL]|L?X{0,3})(I[XV]|V?I{0,3})$");

    //[Bon exemple] Version améliorée qui réutilise des objets
    static boolean isRomanNumerial(String s) {
        return ROMAN.matcher(s).matches();
    }

    //[Pas un bon exemple] Les performances sont médiocres en cas d'utilisation répétée
    static boolean isRomanNumerialBad(String s) {
        return s.matches("^(?=.)M*(C[MD]|D?C{0,3})" +
                "(X[CL]|L?X{0,3})(I[XV]|V?I{0,3})$");
    }
}

Élément 7 Supprimer les références aux objets obsolètes

--Définissez null pour les références qui ne sont plus utilisées.

• La définition d'une référence d'objet sur null doit être une exception plutôt que normale.
• Le meilleur moyen de se débarrasser des références obsolètes est de sortir les variables qui les contenaient du champ d'application.

public class Stack {
    private Object[] elements;
    private int size = 0;
    private static final int DEFAULT_INITIAL_CAPACITY = 16;
    public Stack() {
        this.elements = new Object[DEFAULT_INITIAL_CAPACITY];
    }
    public void push(Object e) {
        ensureCapacity();
        elements[size++] = e;
    }
    public Object pop() {
        if (size == 0)
            throw new EmptyStackException();
        Object result = elements[--size];
        elements[size] = null;  //■ Supprimer les références obsolètes ■
        return result;
    }
    //Si vous devez l'agrandir, doublez-le. Sécurisez au moins une capacité.
    private void ensureCapacity() {
        if (elements.length == size) {
            elements = Arrays.copyOf(elements, 2 * size + 1);
        }
    }
}

Point 8 Évitez les finisseurs et les nettoyants

• Les finaliseurs sont imprévisibles, généralement dangereux et généralement inutiles.
• L'alternative du finaliseur de Java 9 est plus propre, moins dangereuse que le finaliseur, mais toujours imprévisible, lente et généralement inutile.
• Au lieu d'un finaliseur ou d'un nettoyeur, implémentez ʻAutoClosable` et demandez que la méthode close soit appelée lorsqu'elle n'est plus nécessaire. Utilisez généralement try-with-resource pour fermer.

Élément 9 Sélectionnez try-with-resources plutôt que try-finally

comme son nom l'indique.