«

From the compiler complaints I guess this is not possible, yet....

----------------------------
public class MyClass
{
public enum Things
{
ONE,TWO
}

public boolean process(Things thing)
{
boolean success = false;

switch ( thing )
{
case Things.ONE:
success = doStuff(1);
break;

case Things.TWO:
success = doStuff(2);
break;
}

return success;
}
------------------------------

Is there a way to use an enum in a switch statement?

--
Wojtek

On Wed, 07 Mar 2007 16:32:03 -0000, Wojtek <> wrote:

> From the compiler complaints I guess this is not possible, yet....
>
> ----------------------------
> public class MyClass
> {
> public enum Things
> {
> ONE,TWO
> }
>
> public boolean process(Things thing)
> {
> boolean success = false;
>
> switch ( thing )
> {
> case Things.ONE:
> success = doStuff(1);
> break;
>
> case Things.TWO:
> success = doStuff(2);
> break;
> }
>
> return success;
> }
> ------------------------------
>
> Is there a way to use an enum in a switch statement?

You don't need to qualify the enum constants. In fact, you are only
allowed to use unqualified names. So it should be:

switch (thing)
{
case ONE:
// Do something.
case TWO:
// Do something else.
}

Dan.

--
Daniel Dyer
http://www.uncommons.org

Daniel Dyer wrote :
> On Wed, 07 Mar 2007 16:32:03 -0000, Wojtek <> wrote:
>
>> From the compiler complaints I guess this is not possible, yet....
>>
>> ----------------------------
>> public class MyClass
>> {
>> public enum Things
>> {
>> ONE,TWO
>> }
>>
>> public boolean process(Things thing)
>> {
>> boolean success = false;
>>
>> switch ( thing )
>> {
>> case Things.ONE:
>> success = doStuff(1);
>> break;
>>
>> case Things.TWO:
>> success = doStuff(2);
>> break;
>> }
>>
>> return success;
>> }
>> ------------------------------
>>
>> Is there a way to use an enum in a switch statement?
>
> You don't need to qualify the enum constants. In fact, you are only allowed
> to use unqualified names. So it should be:
>
> switch (thing)
> {
> case ONE:
> // Do something.
> case TWO:
> // Do something else.
> }
>
> Dan.

OK, but what if the enum is from another class? I must then qualify it.

BTW I ended up using an if/else if tree, though I would rather use a
switch/case.

--
Wojtek

On Wed, 07 Mar 2007 17:36:49 -0000, Wojtek <> wrote:

>>> Is there a way to use an enum in a switch statement?
>>
>> You don't need to qualify the enum constants. In fact, you are only
>> allowed to use unqualified names. So it should be:
>>
>> switch (thing)
>> {
>> case ONE:
>> // Do something.
>> case TWO:
>> // Do something else.
>> }
>>
>> Dan.
>
> OK, but what if the enum is from another class? I must then qualify it.
>
> BTW I ended up using an if/else if tree, though I would rather use a
> switch/case.

Did you try it with the switch statement and the unqualified labels? The
compiler knows what class the enum constants are from because it knows the
type of the argument to the switch statement.

Dan.

--
Daniel Dyer
http://www.uncommons.org

Daniel Dyer wrote :

>
> Did you try it with the switch statement and the unqualified labels? The
> compiler knows what class the enum constants are from because it knows the
> type of the argument to the switch statement.

It works.

I would not have thought of this.....

Thanks!

--
Wojtek

On Mar 7, 10:06 am, "Daniel Dyer" <"You don't need it"> wrote:
> On Wed, 07 Mar 2007 17:36:49 -0000, Wojtek <nowh...@a.com> wrote:
> >>> Is there a way to use an enum in a switch statement?
>
> >> You don't need to qualify the enum constants. In fact, you are only
> >> allowed to use unqualified names. So it should be:
>
> >> switch (thing)
> >> {
> >> case ONE:
> >> // Do something.
> >> case TWO:
> >> // Do something else.
> >> }
>
> >> Dan.
>
> > OK, but what if the enum is from another class? I must then qualify it.
>
> > BTW I ended up using an if/else if tree, though I would rather use a
> > switch/case.
>
> Did you try it with the switch statement and the unqualified labels? The
> compiler knows what class the enum constants are from because it knows the
> type of the argument to the switch statement.
>
> Dan.
>
> --
> Daniel Dyerhttp://www.uncommons.org

Or, even better... Ever hear of Polymorphism?

// Look ma! No Switches!
public class MyClass {
public enum Things {
ONE {
public boolean doStuff(MyClass myClass) {
return myClass.doStuff(1);
}
},
TWO {
public boolean doStuff(MyClass myClass) {
return myClass.doStuff(2);
}
}
;
public abstract boolean doStuff(MyClass myClass);

}

public boolean process(Things thing) {
return thing.doStuff(this);
}

private boolean doStuff(int i) {
return false;
}
}

In article <>, Wojtek <>
wrote:

> Daniel Dyer wrote :
>
> >
> > Did you try it with the switch statement and the unqualified labels? The
> > compiler knows what class the enum constants are from because it knows the
> > type of the argument to the switch statement.
>
> It works.
>
> I would not have thought of this.....
>
> Thanks!

A more careful examination of the compiler error would actually tell you
this. I learned it the hard way after adopting a practice in an ongoing
project of *always* qualifying our enum references. The compiler
squawked and I had to read it several times to fully grasp that it was
telling me I could not do so.

= Steve =
--
Steve W. Jackson
Montgomery, Alabama

Daniel Dyer wrote :
>
> The
> compiler knows what class the enum constants are from because it knows the
> type of the argument to the switch statement.

Argh, inconsistencies drive me nuts...

So the compiler knows about the enum constants from the switch, but If
I have:

if ( thing == ONE )

That fails because I have not qualified the enum constant.

--
Wojtek

Daniel Pitts wrote :
> On Mar 7, 10:06 am, "Daniel Dyer" <"You don't need it"> wrote:
>> On Wed, 07 Mar 2007 17:36:49 -0000, Wojtek <nowh...@a.com> wrote:
>>>>> Is there a way to use an enum in a switch statement?
>>>> You don't need to qualify the enum constants. In fact, you are only
>>>> allowed to use unqualified names. So it should be:
>>>> switch (thing)
>>>> {
>>>> case ONE:
>>>> // Do something.
>>>> case TWO:
>>>> // Do something else.
>>>> }
>>
>>>> Dan.
>>
>>> OK, but what if the enum is from another class? I must then qualify it.
>>> BTW I ended up using an if/else if tree, though I would rather use a
>>> switch/case.
>>
>> Did you try it with the switch statement and the unqualified labels? The
>> compiler knows what class the enum constants are from because it knows the
>> type of the argument to the switch statement.
>>
>> Dan.
>>
>> --
>> Daniel Dyerhttp://www.uncommons.org
>
> Or, even better... Ever hear of Polymorphism?
>
> // Look ma! No Switches!
> public class MyClass {
> public enum Things {
> ONE {
> public boolean doStuff(MyClass myClass) {
> return myClass.doStuff(1);
> }
> },
> TWO {
> public boolean doStuff(MyClass myClass) {
> return myClass.doStuff(2);
> }
> }
> ;
> public abstract boolean doStuff(MyClass myClass);
>
> }
>
> public boolean process(Things thing) {
> return thing.doStuff(this);
> }
>
> private boolean doStuff(int i) {
> return false;
> }
> }

Well, ok, except that there is more happening in each case than a
method call. And I need to take the time to sit down and actually READ
about Java 1.5+

Sigh, not enough hours in each day, and those damn deadlines.....

--
Wojtek

Steve W. Jackson wrote :

> A more careful examination of the compiler error would actually tell you
> this. I learned it the hard way after adopting a practice in an ongoing
> project of *always* qualifying our enum references. The compiler
> squawked and I had to read it several times to fully grasp that it was
> telling me I could not do so.

You are right of course. It is just that I am so used to qualifying
things, and along comes this new "feature".

The last thing I would have expected is that the compiler would qualify
it for me AND cause an error if I did.

Fully qualifying the constant should have produced a warning about an
unnecessary cast. IMHO of course

--
Wojtek