[JAVA] Punkt 52: Verwenden Sie Überladung mit Bedacht

52. Überlast sollte mit Vorsicht verwendet werden

• Überladung bestimmt die Methode, die zur Kompilierungszeit aufgerufen werden soll.

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

• Auf der anderen Seite werden Überschreibungen zur Laufzeit und nicht zur Kompilierungszeit festgelegt.

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

• Vermeiden Sie verwirrende Überlastungen. Es ist fraglich, was eine verwirrende Überladung ist, aber es wird akzeptiert, dass Sie keine Methode erstellen sollten, die mit der gleichen Anzahl von Argumenten überladen wird.
• Wenn Sie mit der gleichen Anzahl von Argumenten überladen möchten, sollten Sie eine Methode mit einem anderen Methodennamen erstellen. ObjectOutputStream verfügt über alle primitiven Schreibmethoden, überschreibt jedoch keine Schreibmethoden wie writeBoolean und writeInt und erstellt unterschiedliche Methoden.
• Im Fall eines Konstruktors kann ihm kein anderer Name zugewiesen werden, sodass möglicherweise mehrere Konstruktoren mit derselben Anzahl von Argumenten vorbereitet werden können. Die in solchen Fällen vorgebrachten Argumente sind relativ sicher (Beziehungen, die nicht gegossen werden können), wenn sie sich radikal voneinander unterscheiden.
• Vor Java5 waren primitive Typen und alle Referenztypen grundlegend unterschiedlich, aber das Aufkommen von Autoboxing hob diese Annahme auf. Im folgenden Code scheint intuitiv [-3, -2, -1] [-3, -2, -1] angezeigt zu werden, aber in "Liste entfernen" gibt es eine Methode zum Entfernen, die int als Argument verwendet. Da es überschrieben wird, ist es tatsächlich [-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]
    }
}

• Der folgende Code führt zu einem Kompilierungsfehler im `exec.submit (System.out :: println);` Teil. Diese Submit-Methode ist mit `submit (Runnable Task);` und submit (Callable <T> Task); überladen, sodass der Compiler nicht bestimmen kann, welche verwendet werden soll. (** Ich verstehe nicht, warum es schwer zu beurteilen ist. `` System.out :: println``` ist eine ungenaue Methodenreferenz oder so **). Um Verwirrung zu vermeiden, sollten Sie auf jeden Fall eine Überlastung mit verschiedenen Funktionsschnittstellen an derselben Argumentposition vermeiden.

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); //Kompilierungsfehler

    }
}

• Wenn Sie aufgrund einer Änderung des zuvor erstellten Codes überladen müssen, stellen Sie sicher, dass der gleiche Vorgang ausgeführt wird.

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