Java 5 Part 2 CSE301 University of Sunderland Harry Erwin, PhD

Introduction Java 5 has been changed to improve the language. This lecture will discuss the changes. You will be tested on your knowledge of Java 5. References include: –McLaughlin and Flanagan, 2004, Java 1.5 Tiger: A Developer’s Notebook, O’Reilly –Flanagan, 2005, Java in a Nutshell, 5 th edition, O’Reilly

Topics Part 1 (Last Lecture) Arrays Queues Overriding return types Unicode StringBuilder Generics Part 2 (Today) Enumerated types Boxing Annotations for/in Static imports Formatting Threading

Enumerated types If you’ve worked with C++, you already know how enums can be used as integer types to avoid the need for ‘magic numbers’. In Java 1.4 and earlier, there were two ways to define new types: classes and interfaces. This did not cover some very specific programming needs. One such need was for a type that could have a very limited number of values. The new enumerated type or enum serves this need. (An enum is just a Java class.) Many potential questions throughout.

enum Syntax enum enumName {list of values}; –The value list names are all uppercase by convention. Comma-separated. See next slide for an example. Optional components: –interfaces that are implemented by the enum –variable definitions (an enum is a class) –method definitions (an enum is a class) –Value-specific class bodies

enum Syntax Example public enum Foo { BAR(0), BAZ(1), QUUX(42); //values come first Foo(int val){ // constructor (private by default) this.val = val; } private int val = 0; // internal variable public void quuux(long val2) {return;} public String getDescription(){ switch(this){ case BAR: return “BAR-0”; break; case BAZ: return “BAZ-1”; break; default: return “”+val+“?”; }

A Few Points An enum is a class, not a primitive type. Enums extend java.lang.Enum, which is not an enumerated type. Enumerated types are not integers. Enumerated types can’t have public constructors. Enumerated values are public, static, and final. Enumerated values support comparison by == and equals().

More Points Enums are comparable (have an order). Enums provide toString(), returning the name of the value. Enums provide a valueOf(String val) method to convert a String to a value. Recognises the names. Enums provide a final method named ordinal(), which is the integer position of the value in the list. Enums provide a values() method to support enumeration over the value list.

Inline Enums You can declare an enum type within your class rather than at the top level if it is associated with that class. To access it outside your class, make it visible (i.e., not private) and refer to it as YourClassName.EnumName

Iterating Over an Emun First, you use the values() method to get an array of the values in the type. Name[] nameValues = Name.values(); Then you can iterate in the normal way. Or, use the following syntax: for(Name n : Name.values()){ whatever you want to do with each name; } This is a variant of the new for/in syntax (qv).

Enum and Switch Do the following: switch(enumerated value){ case value1: …; case value2: …; … case lastvalue: …; default: …; } Java writes a jump-table to handle this.

Enum and Map The values of an enum are Objects and can serve as indices of a map! Suppose you have an enum called Foo, and corresponding values in some class called Bar, You can create an EnumMap around the two classes An easy way that stores a full list of the enum is: EnumMap theMap = EnumMap (Foo.class); Then all you need to do is initialise the values!

EnumSet This is used to represent combinations of features that can occur independently. First you define the enum enumName Then you create an enumSet to represent the features. There are a number of static member functions in EnumSet to do this.

EnumSet Static Member Functions allOf(Class elementType); complementOf(EnumSet e); copyOf(Collection c); noneOf(Class elementType); of(one to five elements of the enum); range(E from, E to); // avoid! If the enum changes, you’re hash! clone(); contains(E e); // to check whether e is present.

Boxing Instances of primitive types are not objects. To create an object for a primitive type value, you have to wrap it in the corresponding reference type—Boolean, Character, Integer, Float, etc. You must use reference types in Collections. This can be an utter pain. Java has added autoboxing and unboxing. Those features automagically handle this wrapping and unwrapping via typecasts. Don’t unbox null; you’ll get an exception! Also watch for problems with boolean expressions! Test questions.

varargs Advanced topic. Just be aware that you can write Java methods that take multiple arguments of the same type. The number of arguments need not be predetermined.

Annotations This is a standard way to annotate your code. There are three standard annotation types: just before a method definition indicates that it overrides a superclass method. just before a definition indicates that its use is discouraged of “warnings”}) indicates that the following code should have specific compiler warnings turned off You can also invent your own annotations and even annotate your annotations.

for/in Also known as the enhanced for. Gets rid of the need to use an Iterator and simplifies for loops. Syntax: for(Object obj : collection){ operate on obj; // pseudo-code } This also works with a generic collection with members that are of a given type. String concatenation doesn’t work well, though. Test questions.

for/in for Arrays Suppose anArray is of type T[], where T is a reference or primitive type. Then you can loop through it as follows: for(T t : anArray){ // t gets set to anArray[i] //for each i from 0 to the end of the array operate on t // again pseudo-code } Note the types must be compatible. The collection or array can be declared final (non-modifiable) for safety. Test questions.

Static imports This allows you to import a static class, variable, or enum and reference them with a simple name. import static java.lang.System.out; Now you can refer to out, rather than java.lang.System.out. Also works for static methods (see Arrays and Collections), member types, and enums. Wildcards (*) still work. Test questions.

Formatting Advanced topic. import java.util.Formatter; Allows you to use printf().

Threading Advanced topic covered in a later lecture. I won’t be testing your knowledge of Java 5 threading changes. On the other hand, if you need to use threads in your final year project or other modules, Chris Knowles or I will be happy to discuss this material off-line.