Questão sobre Construtor

[eltonk]

Pessoal,

A questão é a seguinte: Dado o exemplo abaixo, o que vai ocorrer quando for chamado o método main() da classe?

A dúvida, por que ele chama o construtor com o parâmetro String? Qual é a justificativa para isto?

[code]
public class TestConstrutor
{

public TestConstrutor()
{
System.out.println(“padrao”);
}

public TestConstrutor(Object o)
{
System.out.println(“padrao 3”);
}

public TestConstrutor(String t)
{
System.out.println(“padrao 2”);
}

/**
* @param args
*/
public static void main( String[] args )
{
new TestConstrutor(null);

}

}
[/code] :?: :?: :?:

[Rafael_Nunes]

If more than one method declaration is both accessible and applicable to a method invocation, it is necessary to choose one to provide the descriptor for the run-time method dispatch. The Java programming language uses the rule that the most specific method is chosen.

Ou seja, segundo a JLS, a VM invoca o método mais específico quando mais de um atender a uma chamada.

[PadrE]

[quote] public class TestConstrutor
{

public TestConstrutor()
{
   System.out.println("padrao");
}

public TestConstrutor(Object o)
{
   System.out.println("padrao 3");
}

public TestConstrutor(String t)
{
   System.out.println("padrao 2");
}

/**
 * @param args
 */
public static void main( String[] args )
{
   new TestConstrutor(null);

}

}
[/quote]

Bom… como nosso amigo falou, a JVM procura chamar o método mais apropriado a chamada…

Por exemplo…

Se vc tivesse feito:

ele chamaria:

seria

e para

viria

Agora, para essa chamda:

Ele tentaria encontrar o a melhor situação…
que pra ele eh a chamada do método que recebe uma String como padrão…

Chamar o método que não recebe parâmetros ?? Acredito que não, porque vc esta passando um parâmetro… mesmo que ele seja um null (explícito)

Bom, se formos analisar, ele não chamaria o Object, porque null não eh um objeto e sim um valor… apesar de um valor nulo…

Chamar o método que recebe uma String parece ser o mais coerente… pois podemos comparar String’s com valores nulos… o que no meu ver não eh o mesmo com objetos… pois não vemos se uma variável objeto esta valendo null… e sim se ela esta apontando para null… tem uma diferença ai…

Ou a JVM não pensaou em nada disso e foi fazendo um
if… else if… else…

e como o método om String eh o último, acabou sendo ele… :lol:

Fui !

[Rafael_Nunes]

[quote=PadrE]Chamar o método que recebe uma String parece ser o mais coerente… pois podemos comparar String’s com valores nulos… o que no meu ver não eh o mesmo com objetos… pois não vemos se uma variável objeto esta valendo null… e sim se ela esta apontando para null… tem uma diferença ai…

Ou a JVM não pensaou em nada disso e foi fazendo um
if… else if… else…
[/quote]

Não é exatamente assim.
A VM invoca realmente o método que for mais específico/menos abrangente.
Seria como você declarar dois métodos:

metodo(int nro) metodo(long nro)

E fizesse uma chamada:

Seria chamado o primeiro método.

[thingol]

Bom, se formos analisar, ele não chamaria o Object, porque null não eh um objeto e sim um valor… apesar de um valor nulo…

Você pode atribuir null a um parâmetro do tipo Object ou do tipo String. Só que String é mais específico que Object, porque String é uma subclasse de Object.

Se seu exercício tivesse os tipos “Object”, “Number”, “Integer” seria mais fácil de perceber - iria bater com “Integer”, porque Integer é uma subclasse de Number, que é uma subclasse de Object.

[marcel.conti]

eltonk,

você só não pode deixar de lembrar, que se existirem dois ou mais construtores com argumentos de classe que tem o mesmo nível de hierarquia (nem mais nem menos específico), e você chamar a classe passando “null” dará erro de compilação, como por exemplo:

class SuperClass {
}
class SubClassA extends SuperClass {
}
class SubClassB extends SuperClass {
}

class Teste {

Teste() {
    System.out.println("Default");
}
Teste(Object o) {
    System.out.println("Object");
}
Teste(SubClassA sub) {
    System.out.println("SubClassA");
}
Teste(SubClassB sub) {
    System.out.println("SubClassB");
}

public static void main ( String[] args) {
    Teste t = new Teste(null);
}

}

Repare que a classe tem 4 construtores, um sem argumentos, outro com a classe Object e os outros dois com argumentos de classe no mesmo nível de hierarquia:

Object
----+ SuperClass
--------+ SubClassA
--------+ SubClassB

Neste caso, dará erro de compilação, porque você está passando “null” e a sua classe tem dois construtores mais específicos.

[eltonk]

[quote=marcel.conti]eltonk,

você só não pode deixar de lembrar, que se existirem dois ou mais construtores com argumentos de classe que tem o mesmo nível de hierarquia (nem mais nem menos específico), e você chamar a classe passando “null” dará erro de compilação, como por exemplo:

class SuperClass {
}
class SubClassA extends SuperClass {
}
class SubClassB extends SuperClass {
}

class Teste {

Teste() {
    System.out.println("Default");
}
Teste(Object o) {
    System.out.println("Object");
}
Teste(SubClassA sub) {
    System.out.println("SubClassA");
}
Teste(SubClassB sub) {
    System.out.println("SubClassB");
}

public static void main ( String[] args) {
    Teste t = new Teste(null);
}

}

Repare que a classe tem 4 construtores, um sem argumentos, outro com a classe Object e os outros dois com argumentos de classe no mesmo nível de hierarquia:

Object
----+ SuperClass
--------+ SubClassA
--------+ SubClassB

Neste caso, dará erro de compilação, porque você está passando “null” e a sua classe tem dois construtores mais específicos.[/quote]

Perfeito… tanto que a opção por mim escolhida foi “erro de ocmpilação” no teste.
Mas entendi perfeitamente o porque da JVM escolher o construtor com String, no caso por eu citado…

Valeu galera… uma questão a mais para matar na prova