Java 1.5 in a Nutshell

Transcription

1 Java 1.5 in a Nutshell Including Generics, Enumerated Types, Autoboxing/Unboxing, and an Enhanced for Loop CS 2334 University of Oklahoma Brian F. Veale

2 Java 1.5 Java 1.5 has many enhancements Generics Allows a type or method to operate on objects of various type Autoboxing/Unboxing Elimintates manual conversion of primitive types (e.g., int) and wrapper types (e.g., Integer) Enhanced for Loop Eliminates the need for iterators and index variables when iterating over collections and arrays Enumerated Types Static Import Allows the use of static class members without qualifying their name

3 Generics Types that contain data (i.e., lists) are not defined to operate over a specific type of data Instead, they operate over a homogeneous set, where the type is defined at declaration. In Java 1.4 and earlier the type is defined to operate on a specific type of data usually instances of the class Object, which allows us to store any object in the type

4 Disadvantages of the old way StringIntegerDemo.java This example stores Strings in a list of integers. When the example is run, we get casting errors. We must cast the elements in the list as we use them because Java does not know type of the elements in the list. There is no way to statically constrain the list to a set of data of the same type unless you create a new subclass of List for every element type you want to use.

5 The Generics Advantage Polymorphic behavior (just as before) Strong static type checking (compile time) The compiler knows what kind of data the list will hold. In the old way, the type could not be checked until execution of the code causing runtime errors. Compiler detected errors are easier to fix. Less casting required Easier to program Cleaner code

6 How to use Generics Declaring and initializing a list: List<String> stringlist; stringlist = new ArrayList<String>(); Adding to the list: stringlist.add( Hello ); Retrieving from the list: Iterator<String> itr = stringlist.iterator() while( itr.hasnext() ) { String str = itr.next(); System.out.println( str ); }

7 Generics Demo GenericsDemo.java

8 Generics and Comparable When using Generics, the Comparable Interface can be typed just like a Collection can be typed public class AdtType implements Comparable<AdtType> { public int compareto( AdtType other ) This becomes important when working with certain methods in the Collections class binarysearch() depends on Comparable using the same type as the objects stored List that is being searched If you are working with the Collections class and you get a compiler error that seems to be incorrect, this may be the cause.

9 Using Wildcards In the type definition we can use? as a wildcard that allows the type to match everything Object!=? private static void printcollection( Collection<?> c ) Note, when you create collection with?, you cannot arbitrarily add elements of any type to it, because? stands for some unknown type. The following code will result in a compilation error: List<?> list = new ArrayList<String>; list.add( new Object() ); // compilation error

10 Wildcard Methods GenericsDemo.java has two wildcard methods showcollection() By declaring the parameters to be of type Collection<?> or List<?> we can pass a collection or list of any type to the method and iterate through the collection or list and print it to the console.

11 Generic Methods Just like type declarations, methods can be generic They can be parameterized by one or more types Specify the type parameter <T> before the return type. Use T for the type name as a convention whenever there is not something more specific about the type to distinguish it. Multiple types can be used. The convention here is to use T and letters close to T such as S. Specify the type parameters (e.g., <T,S>) before the return type. See showlist() of GenericsDemo.java

12 Generic Methods vs. Wildcard Methods If the type argument is only being used for polymorphism, its only effect is to allow a variety of actual argument types to be used in the method invocation Generic methods are meant to allow us to express dependencies among the type of one or more arguments to a method and/or its return type If this dependency does not exist a generic method should not be used You might want to use a wildcard method instead showlist() in GenericsDemo.java should use wildcards instead of type parameters.

13 AutoBoxing and AutoUnboxing We cannot put an int into a collection because collections can only hold object references You have to box primitive values into the appropriate wrapper class (e.g., an int has to be boxed into an Integer; Collection.add(Integer(intValue)) ). When the object is taken out of the class it must be unboxed. For an int we would call the intvalue() method on the Integer object in the collection. Java 1.5 automates this process when using Generics

14 Enhanced for Loop Iterating over a collection or array is tedious We must use an iterator or an index variable Many opportunities for errors Java 1.5 provides a new for each type of loop See showeachlist() and showeachcollection() in GenericsDemo.java for( Object o : collection ) We can use other types than just Object

15 Nested Enhanced for Loops We can also nest the iteration for( Suit suit : suits ) { for( Rank rank : ranks ) { sorteddeck.add( new Card(suit, rank) ); } }

16 Enumerated Types Enumeration A set of named integer constants that specify all of the legal values a variable of that type may have Example values of a coins enumeration: penny, nickel, dime, quarter, half_dollar, dollar Corresponding code to define the type: public enum coins { PENNY, NICKEL, DIME, QUARTER, HALF_DOLLAR, DOLLAR }; Must be declared as a class variable member.

17 More about enum enum defines a full fledged class Can add arbitrary methods and fields to an enum type Can be used to implement arbitrary interfaces Provides all of the Object methods They are also Comparable and Serializable Demo Card.java and Deal.java Also includes code using Generics and the enhanced for loop

18 Static Import In order to access static members, it is necessary to qualify references with the class they came from: double r = Math.cos( Math.PI * theta ); frame.getcontentpane().add( button, BorderLayout.SOUTH ); The static import construct allows unqualified access to static members without inheriting from the type containing the static members. Instead, we import the members Individiually: import static java.lang.math.pi; En masse: import static java.lang.math.*;

19 Using Static Import Use this vary sparingly! Only use it when you'd otherwise be tempted to declare local copies of the constants or to abuse inheritance. Can make the program hard to read. Used appropriately, it can make the program more readable by removing the boilerplate of repetition of class names. Make sure the reader will know which class the static member comes from.