Item 52: Use overloading judiciously

52. Overload should be used with caution

• Overload determines the method to call at compile time.

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
         */
    }
}

• On the other hand, overrides are determined at run time, not at compile time.

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";
    }
}

• Avoid the use of confusing overloads. It's arguable what a confusing overload is, but it's accepted that you shouldn't create a method that overloads with the same number of arguments.
• If you want to overload with the same number of arguments, you should create a method with a different method name. ObjectOutputStream has all primitive type write methods, but they do not override write such as writeBoolean and writeInt, and create different methods.
• In the case of a constructor, it cannot be given a different name, so it may be possible to prepare multiple constructors with the same number of arguments. The arguments taken in such cases are relatively safe (relationships that cannot be cast) if they are radically different from each other.
• Before Java5, primitive types and all reference types were fundamentally different, but the advent of autoboxing overturned that premise. In the code below, intuitively, [-3, -2, -1] [-3, -2, -1] seems to be displayed, but in Remove of List, there is a remove method that takes an int as an argument. Since it is overridden, it is actually [-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]
    }
}

• The following code will cause a compile error at the exec.submit (System.out :: println); `` `. This submit method is overloaded with `` `submit (Runnable task);` `` and `` `submit (Callable <T> task);` `` so that the compiler cannot determine which to use. (** I don't understand why it's hard to judge. `` `System.out :: println is an inexact method reference or something **). Anyway, to avoid confusion, you should avoid overloading with different functional interfaces at the same argument position.

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); //Compile error

    }
}

• If you have to overload due to a modification of the code you created before, make sure that the same operation is performed.

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