Método em Enums[RESOLVIDO]

Programação Java
#1

Boa tarde a todos,

Estou com uma duvida referente a método em enum. Dado o seguinte código:

public class Bridge {

	public enum Suits {
		NOTRUMP(40) { 
			public int getValue(int bid) {
				return ((bid - 1) * 30) + 40;
			}
	};
			Suits (int points) {
				this.points = points;
			}
			
			private int points;
			public int getValue(int bid) {
				return 2 * bid;
			}
		}
	public static void main(String[] args) {
		System.out.println(Suits.NOTRUMP.getValue(3));
	}
	}

Porque eu não consigo utilizar o método getValue(int bid) do corpo da constante NOTRUMP, se não declarar o mesmo dentro do enum(linha 14) ?

Ou seja tenho que declarar o método duas vezes e mesmo assim o retorno vai ser o equivalente ao método que está no corpo da constante e não o que está fora ! :shock:

Por favor se alguém puder ajudar! :smiley:

#2

Basta chamar:

Mas o enum é mesmo um conjunto de objetos de mesma assinatura. Portanto, você teria que declarar o método da linha 14, nem que fosse apenas como abstract.

#3

[code]
public class Bridge {

public enum Suits {
NOTRUMP(40) {
public int getValue(int bid) {
return ((bid - 1) * 30) + 40;
}
};

  Suits (int points) {
     this.points = points;
  }
		
  private int points;
  public abstract int getValue(int bid);

}

public static void main(String[] args) {
System.out.println(Suits.NOTRUMP.getValue(3));
}
}[/code]

#4

Entendi Vini, mas confundi um pouco não ?

E o que eu acho mais estranho é que tipo sempre o retorno vai ser do método que estiver dentro do corpo da constante…

Se eu to entendendo então o método que fica dentro do enum, é uma “ponte” para poder utilizar o método da constante ? Já que não é retornado nada desse método…

É isso ? :smiley:

#5

Isso é polimorfismo.

O enum nada mais é do que um conjunto de classes que herdam Suits. O Java implicitamente cria uma classe anônima para o NOTRUMPS, que implementa Suits.
Seria mais ou menos o equivalmente a isso aqui (é assim que se simulava esses enums antes do Java 5):

[code]public class Suits {
public static NOTRUMPS = new NoTrumps(40);

private int points;

protected Suits(int points) {
    this.points = points;
}

public abstract int getValue(int bid);

private static class NoTrumps extends Suits {
    public NoTrumps(int points) { super(points); }

    public int getValue(int bid) {
           return ((bid - 1) * 30) + 40;  
    }
}

}

//No mais
Suits s = Suits.NOTRUMPS;
int points = s.getValue(10);
[/code]

#6

Certo dessa forma ficou claro,

Mas então no caso do método não ser abstract, ele ter um corpo dentro do enum, sendo que na verdade a implementação que será usada é do corpo da constante…

Nesse caso, que utilidade tem o corpo do método que está dentro do escopo de enum? Nenhuma?

:smiley:

#7

Nenhuma. Vc jamais conseguiria fazer o cast para a inner class anônima.
Você poderia usa-lo no máximo de suporte a outros métodos, que fossem visíveis.

#8

Vlw Vini,

Bom dia ae :smiley:

#9