ta assim na pg 166 portugues, mais assim eu acho que os dois if retorna false ja que c1 e c2 nao faz referencia para o mesmo objeto to certo? acho que seria true assim:
c1=c2;
c1 referenciava ao mesmo objeto que c2… mais no livro ela afirma que a sintaxe la em cima ta correta iai eu q to equivocado ou realmente foi mais uns dos belos erros de tradução…quem tiver o livro em ingles ai e dar essa verificada seria legal…
Sim,eles refenciam o mesmo objeto, objeto enum é o mesmo,embora o conteudo de cada posicao da enum,tenha referencia a outros dois objetos,mas…Elas residem no mesmo objeto
josenaldo
Isso mesmo!
Os objetos RED e BLUE são do tipo Color e são as duas ÚNICAS instâncias desse tipo!
Na linha
c1 e c2 recebem o mesmo conteúdo, ou seja, o padrão de bits que indica a localização do objeto RED.
Portando, ao usar o operador ==, como na linha
o resultado é true e é impresso == na tela.
LPJava
perai, entao enum eh um objeto ou tipo? nao entendi isso aqui retorna falso:
Colorc1=Color.RED;Colorc2=Color.BLUE;
o que é avaliado nessa caso de enum? é a constante?
josenaldo
A Enum é um…
(que rufem os tambores… )
Uma classe!
Ela pode ter métodos. Pode ter variáveis. Pode ter a zona ttoda!
A diferença principal ara uma classe normal é que a enum possui um conjunto limitado de objetos que são instanciados na hora em que ela eh carregada. Inclusive ela pode ter construtores, com argumentos e até mesmo sobrecarregados! :shock:
A Enum é a classe… As constantes na verdade são objetos perfeitamente funcionais!
Enum na verdade é apenas um atalho para usar objetos public static const final e para restringir esses objetos a um grupo delimitado.
LPJava
ah saquei entao RED é um objeto da class enum?
josenaldo
Não… RED é um objeto da classe Color, que na verdade eh uma enum. Enum é um tipo especial de classe. rs
LPJava
é isso que queria entender entao enum eh um tipo especial e as constante sao objeto por isso que se eu alterar c2 = Color.BLUE return false devido RED e BLUE ser objetos distintos??
josenaldo
Exatamente!
Mantu
Não é verdade… RED é uma constante da classe Color. RED é um (“referencia um” seria mais apropriado…) objeto de uma classe anônima, a qual extende a classe Color.
Sami_Koivu
Desculpas, eu não comuniquei isso de uma forma muito clara no outro thread. No caso deste enum, RED seria uma instândia da classe Color, mesmo. Não há necessidade para extender a classe Color se não tem um método que os RED e BLUE sobre-escrevem.
josenaldo
Não é verdade… RED é uma constante da classe Color. RED é um ("referencia um" seria mais apropriado…) objeto de uma classe anônima, a qual extende a classe Color.
Rapaz… rsrsrs dá uma olhada abaixo… Se eu estiver errado, eles tb estão (ou eu interpretei mal :P:P)
De acordo com o Kathy Sierra:
public class CoffeeTest1 {
enum CoffeeSize { BIG, HUGE, OVERWHELMING }; // <--semicolon
// is optional here
public static void main(String[] args) {
Coffee drink = new Coffee();
drink.size = CoffeeSize.BIG;
}
}
So what gets created when you make an enum? The most important thing to remember is that enums are not Strings or ints! Each of the enumerated CoffeeSize types are actually instances of CoffeeSize. In other words, BIG is of type CoffeeSize. Think of an enum as a kind of class, that looks something (but not exactly) like this:
// conceptual example of how you can think
// about enums
class CoffeeSize {
public static final CoffeeSize BIG =
new CoffeeSize("BIG", 0);
public static final CoffeeSize HUGE =
new CoffeeSize("HUGE", 1);
public static final CoffeeSize OVERWHELMING =
new CoffeeSize("OVERWHELMING", 2);
public CoffeeSize(String enumName, int index) {
// stuff here
}
public static void main(String[] args) {
System.out.println(CoffeeSize.BIG);
}
}
Notice how each of the enumerated values, BIG, HUGE, and OVERWHELMING, are instances of type CoffeeSize. They’re represented as static and final, which in the Java world, is thought of as a constant. Also notice that each enum value knows its index or position?in other words, the order in which enum values are declared matters. You can think of the CoffeeSize enums as existing in an array of type CoffeeSize, and as you’ll see in a later chapter, you can iterate through the values of an enum by invoking the values() method on any enum type. (Don’t worry about that in this chapter.)
The body of an enum type may contain enum constants. An enum constant defines an instance of the enum type. An enum type has no instances other than those defined by its enum constants.
josenaldo
Creio que mantu confundiu devido à este trecho:
And finally, you can define something really strange in an enum that looks like an anonymous inner class (which we talk about in Chapter 8). It’s known as a constant specific class body, and you use it when you need a particular constant to override a method defined in the enum. Imagine this scenario: you want enums to have two methods?one for ounces and one for lid code (a String). Now imagine that most coffee sizes use the same lid code, “B”, but the OVERWHELMING size uses type “A”. You can define a getLidCode() method in the CoffeeSize enum that returns “B”, but then you need a way to override it for OVERWHELMING. You don’t want to do some hard-to-maintain if/then code in the getLidCode() method, so the best approach might be to somehow have the OVERWHELMING constant override the getLidCode() method. This looks strange, but you need to understand the basic declaration rules:
enum CoffeeSize {
BIG(8),
HUGE(10),
OVERWHELMING(16) { // start a code block that defines
// the "body" for this constant
public String getLidCode() { // override the method
// defined in CoffeeSize
return "A";
}
}; // <-- the semicolon is REQUIRED when you have a body
CoffeeSize(int ounces) {
this.ounces = ounces;
}
private int ounces;
public int getOunces() {
return ounces;
}
public String getLidCode() { // this method is overridden
// by the OVERWHELMING constant
return "B"; // the default value we want to return for
// CoffeeSize constants
}
}
Ou seja, no caso de você querer sobrescrever um método da enum, aí sim, A INSTANCIA DA ENUM QUE ESTÁ SOBREESCREVENDO O MÉTODO é que é como uma classe anônima que extende a enum.
Mantu
Verdade!
Fiz uns testes aqui interessantes que mostram isso que o Sami falou!
Nesse primeiro caso aqui, por exemplo:
(ou eu interpretei mal :P:P)