Overloading java

Programação
#1

Fazer overloading de um método por mais de 12 vezes causa o erro memory deadlock. Argumente a afirmação.

#2

Baseado no que eu entendi da sua afirmação eu escrevi o código abaixo.

import java.io.File;
import java.net.URI;
import java.nio.file.Path;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Stream;

public class Main {
  public static void main(String... args) {
    testando("aaa");
    testando(1);
    testando(2d);
    testando(3f);
    testando(4L);
    testando((byte) 5);
    testando((short) 6);
    testando(true);
    testando('a');
    testando(List.of());
    testando(Map.of());
    testando(Set.of());
    testando(Stream.of());
    testando(Path.of(""));
    testando(URI.create(""));
    testando(new Main());
    testando(new File(""));
    testando(new Exception());
    testando(new Error());
    testando();
  } // @formatter:off

  private static void testando(short x)     { System.out.println(x); }
  private static void testando(byte x)      { System.out.println(x); }
  private static void testando(int x)       { System.out.println(x); }
  private static void testando(float x)     { System.out.println(x); }
  private static void testando(long x)      { System.out.println(x); }
  private static void testando(double x)    { System.out.println(x); }
  private static void testando(boolean x)   { System.out.println(x); }
  private static void testando(char x)      { System.out.println(x); }
  private static void testando(String x)    { System.out.println(x); }
  private static void testando(List<?> x)   { System.out.println(x); }
  private static void testando(Map<?, ?> x) { System.out.println(x); }
  private static void testando(Set<?> x)    { System.out.println(x); }
  private static void testando(Stream<?> x) { System.out.println(x); }
  private static void testando(Main x)      { System.out.println(x); }
  private static void testando(Path x)      { System.out.println(x); }
  private static void testando(File x)      { System.out.println(x); }
  private static void testando(URI x)       { System.out.println(x); }
  private static void testando(Exception x) { System.out.println(x); }
  private static void testando(Error x)     { System.out.println(x); }
  private static void testando()            { System.out.println("hello"); }
}

O método testando tem 20 sobrecargas. Usei Java 11 e tudo funcionou perfeitamente.

Então parece que a afirmação é falsa.

Qual código você usou para testar? Se puder dar mais informação seria bom.

Overloading
#3

Foi uma pergunta que saiu no teste da minha cidade

#4

Que pergunta estranha.

Deadlock, pelo que entendo, é o tipo de problema que pode ocorrer quando vc trabalha com múltiplas threads. Olha essa resposta que interessante:

E olha o vídeo abaixo, a partir do instante 15:26 ele explica o que é deadlock.

#5

Tem certeza que a pergunta foi exatamente essa? Pois ela não faz o menor sentido…

#6

Sim foi essa. Talvez seja q ele se referiu a algum computador com pouca threads… Por isso limitou por 12

#7

Mas overloading não tem nenhuma relação com deadlock.

Overloading é quando você tem métodos de mesmo nome mas com parâmetros diferentes.

Deadlock é quando você tem dois processos concorrentes “travados” pois um está esperando pela conclusão do outro.

#8

Se a pergunta foi somente aquela frase, sem nenhum outro contexto adicional, então ela não faz o menor sentido. A quantidade de threads da máquina e o deadlock não tem nada a ver com a quantidade de overloadings de um método…

1 curtida