Generic Subroutines and Exceptions CS 351 Programming Paradigms

Generic Subroutines and Exceptions CS 351 – Programming Paradigms

Motivations Subroutines provide a natural way of abstracting data operations. l With large programs containing many methods it is possible that subroutines will be needed to perform similar operations on many different types. l Consider some code from any language: l String add (String a, String b) return a + b; int add ( int a, int b ) return a + b; double add ( double a, double b) return a + b; What is wrong with this code? l Nothing! l

Motivations l l l The code is correct but the repetitious operations must be defined statically many times over. We need a form of parametric parameterisation i. e the subroutine should only be written once and be capable of accepting any arguments. This idea is known as generic programming. In Java version 5, generic programming has been added. In C++, generics are known as templates. Other languages that feature generics are Ada, Modula-3 and C#.

Generics are especially helpful for creating container classes. l Container classes are data abstractions that hold a collection of objects. l The operation of the container class is independent of the type of object stored. l Some examples of container classes include…. l l l Stack Queue Set Heap…

Generic Subroutines Generic subroutines are needed in generic classes. l They allow a method to be parameterised by a single type. l Hence our earlier example becomes vastly simplified: l public T <T> add ( T a, T b) return a + b; This code is now identical to the first slide except we now have a generic type T passed as a parameter to the add method. l Hence we can now call the code: l int c = add( 5 , 7 ); double d = add ( 4. 5, 6. 9 ); String concat = add( “gen” , “erics” );

Implementing Generics l l l In C++, they are a static mechanism. All of the work required to use multiple instances of the generic code is handled by the compiler. The compiler creates a separate copy of the code for every instance. In Java, all instances of the generic code will shae that same code at run-time. If we call some generic parameter, T in Java, this behaves identically to java. lang. Object except that we do not have to use casts.

Generics in C++ The syntax is similar but the behaviour is more flexiable than Java. l However it is easier to make mistakes with C++. l A generic add method in C++: l template<typename T> T add (T a, T b) { return a+b; } To call the method add(5, 6); add(5. 6 , 7. 8); l The compiler figures out all of the hard work. l

Generics in Java ``Old’’ Java: l A Vector of ints: l /* Adding to a Vector */ Vector v = new Vector(); for ( int i = 0; i < 10; i++ ) v. add(new Integer(i)); /* Removing from a Vector */ for ( int z = 0; z<v. size(); z++ ) int a = ((Integer)v. element. At(z)). int. Value(); Looks very messy especially, the cast involved when reading from the Vector l With generics: l /* Adding to a Vector */ /* Removing from Vector */ Vector<Integer> v = new Vector<Integer> (); for (int i = 0; i < 10 ; i++) v. add(i); for (int a : v)

Java Generics : Erasure Generics in Java are defined in terms of type erasure. l This means that every generic type parameter is replaced by java. lang. Object and casts back to concrete types are automatically inserted into the code by the compiler. l E. g. l class choice <T> { public boolean best ( T a , T b ) {} } Is replaced by: class choice { public boolean best ( Object a, Object b ) {} } l This is done to provide backwards compatibility with older non generic Java code.

Java Generics l Recall the C++ example: template<typename T> T add (T a, T b) { return a+b; } This allows any number ( int, float, short, double etc ) to be added together. l How can we achieve this is Java? l public <T> T add ( T a, T b ) { return a+b; } l Is this correct?

Java Generics l Lets perform the type erasure: public Object add ( Object a, Object b ) { return a+b; } Does this compile? l No!, because the + operator is not applicable to Object. l We must modify the code to make it typesafe so it can compile: l

Java Generics public <T extends Number> T add ( T a, T b ) { return a+b; } l l l We have to impose a higher bound on the type passed to the generic method. In this case we are saying that the type passed in will be a subclass of java. lang. Number Will the code compile now? Nope! We still have to make sure that it is typesafe.

Java Generics public <T extends Number> T add ( T a, T b ) { if ( T instanceof Integer ) return a. int. Value() + b. int. Value(); if ( T instanceof Double ) return a. double. Value() + b. double. Value(); return null; } public static void main( String args [] ) { int a = add (5 , 6); double b = add ( 7. 9, 11. 3 ); } l We are passing ints and doubles to add but the add method takes Integers and Doubles, how is this?