[JAVA] Item 52: Utiliser la surcharge judicieusement

52. La surcharge doit être utilisée avec prudence

• La surcharge détermine la méthode à appeler au moment de la compilation.

package tryAny.effectiveJava;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

public class OverloadTest {
    public static String classify(Set<?> s) {
        return "Set";
    }

    public static String classify(List<?> s) {
        return "List";
    }

    public static String classify(Collection<?> s) {
        return "Collection";
    }

    public static void main(String[] args) {
        Collection<?>[] collections = { new HashSet<String>(), new ArrayList<String>(),
                new HashMap<String, String>().values() };

        for (Collection<?> c : collections) {
            System.out.println(classify(c));
        }
        /**
         * Collection <br>
         * Collection <br>
         * Collection
         */
    }
}

• D'un autre côté, les remplacements sont déterminés au moment de l'exécution, pas au moment de la compilation.

package tryAny.effectiveJava;

import java.util.List;

public class OverrideTest {
    public static void main(String[] args) {
        List<Wine> l = List.of(new Wine(), new SparklingWine(), new Champagne());

        for (Wine w : l) {
            System.out.println(w.name());
            /**
             * wine<br>
             * sparkling wine<br>
             * champagne
             */
        }
    }
}

class Wine {
    String name() {
        return "wine";
    }
}

class SparklingWine extends Wine {
    @Override
    String name() {
        return "sparkling wine";
    }
}

class Champagne extends SparklingWine {
    @Override
    String name() {
        return "champagne";
    }
}

• Évitez d'utiliser des surcharges déroutantes. On peut discuter de ce qu'est une surcharge déroutante, mais il est admis que vous ne devriez pas créer une méthode qui surcharge avec le même nombre d'arguments.
• Si vous souhaitez surcharger avec le même nombre d'arguments, vous devez créer une méthode avec un nom de méthode différent. ObjectOutputStream a toutes les méthodes d'écriture de type primitif, mais elles ne remplacent pas write comme writeBoolean et writeInt, et créent des méthodes différentes.
• Dans le cas d'un constructeur, il ne peut pas recevoir un nom différent, il peut donc être possible de préparer plusieurs constructeurs avec le même nombre d'arguments. Les arguments pris dans de tels cas sont relativement sûrs (relations qui ne peuvent pas être exprimées) s'ils sont radicalement différents les uns des autres.
• Avant Java5, les types primitifs et tous les types de référence étaient fondamentalement différents, mais l'avènement de l'autoboxing a renversé cette prémisse. Dans le code ci-dessous, intuitivement, [-3, -2, -1] [-3, -2, -1] semble être affiché, mais dans Remove of List, il existe une méthode remove qui prend int comme argument. Puisqu'il est remplacé, il est en fait [-3, -2, -1] [-2, 0, 2].

package tryAny.effectiveJava;

import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import java.util.TreeSet;

public class SetList {
    public static void main(String[] args) {
        Set<Integer> s = new TreeSet<>();
        List<Integer> l = new ArrayList<>();

        for (int i = -3; i < 3; i++) {
            s.add(i);
            l.add(i);
        }

        for (int i = 0; i < 3; i++) {
            s.remove(i);
            l.remove(i);
        }

        System.out.println(s + "" + l);// [-3, -2, -1] [-2, 0, 2]
    }
}

• Le code suivant entraînera une erreur de compilation à exec.submit (System.out :: println); `` `. Cette méthode de soumission est surchargée avec `` `` submit (Runnable task); `` et `` `` submit (Callable <T> task); `` `` afin que le compilateur ne puisse pas déterminer lequel utiliser. (** Je ne comprends pas pourquoi il est difficile de juger. `` `` System.out :: println est une référence de méthode inexacte ou quelque chose **). Quoi qu'il en soit, pour éviter toute confusion, vous devez éviter de surcharger avec différentes interfaces fonctionnelles à la même position d'argument.

package tryAny.effectiveJava;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Snippet {
    public static void main(String[] args) {
        new Thread(System.out::println).start();
        ExecutorService exec = Executors.newCachedThreadPool();
        exec.submit(System.out::println); //Erreur de compilation

    }
}

• Si vous devez surcharger en raison d'une modification du code que vous avez créé auparavant, assurez-vous que la même opération est effectuée.

// Ensuring that 2 methods have identical behavior by forwarding
public boolean contentEquals(StringBuffer sb) {
    return contentEquals((CharSequence) sb);
}