else
return Answers.NEVER; // 2%
}
}
class AskMe {
static void answer(Answers result) {
switch(result) {
case NO:
System.out.println("No");
break;
case YES:
System.out.println("Yes");
break;
case MAYBE:
System.out.println("Maybe");
break;
case LATER:
System.out.println("Later");
break;
case SOON:
System.out.println("Soon");
break;
case NEVER:
System.out.println("Never");
break;
}
}
public static void main(String args[]) {
Question q = new Question();
answer(q.ask());
answer(q.ask());
answer(q.ask());
answer(q.ask());
}
}
Type Wrappers
As you know, Java uses primitive types (also called simple types), such as int or double, to
hold the basic data types supported by the language. Primitive types, rather than objects,
are used for these quantities for the sake of performance. Using objects for these values would
add an unacceptable overhead to even the simplest of calculations. Thus, the primitive types
are not part of the object hierarchy, and they do not inherit Object.
Despite the performance benefit offered by the primitive types, there are times when
you will need an object representation. For example, you can't pass a primitive type by
reference to a method. Also, many of the standard data structures implemented by Java
operate on objects, which means that you can't use these data structures to store primitive
types. To handle these (and other) situations, Java provides type wrappers, which are classes
that encapsulate a primitive type within an object. The type wrapper classes are described
Search WWH :
