1. Exam Objective : Legal return types PRESENTED BY : SRINIVAS VG

2. Agenda :  Return types on overloaded methods  Overriding and Return types, and Covariant returns  Returning a value

3. Return types on Overloaded methods :  To overload a method, you must change the argument list Eg:- public class Foo{ void go(){} } public class Bar extends Foo{ String go(int x){ return null; }

4.  As long as there is change in argument list, return type doesn’t have to match with that of superclass version  Find the error – public class Foo{ void go(){} } public class Bar extends Foo{ String go(){ return null; } }  Can’t change only the return type

5. Return types while Overriding :  Only in JAVA 5 you’re allowed to change the return type while overriding only in case of covariant returns Eg : Look at the covariant return class Alpha { Alpha dostuff(char c){ return new Alpha(); } class Beta extends Alpha { Beta doStuff(char c){ // legal override in java 1.5 return new Beta(); }

6. Covariant returns :  A class could not override the return type of the methods it inherits from a superclass  Applicable only for JAVA 5 version  A method in a subclass may return an object whose type is a subclass of the type returned by the method with the same signature in the superclass Alpha Beta

7. Till now we know :  Overloaded methods can change the return types  Overridden methods cannot, except in the case of covariant returns

8. Returning a value : There are 6 rules  You can return null with an object reference return type Eg: public Button dostuff(){ return null; } Eg; class Dummy{ public Dummy dum(){ return null; } public static void main(String args[]){ Dummy n=new Dummy(); Dummy h=n.dum(); System.out.println(h); }

9.  An array can be returned Eg: public String[] go(){ return new String[]{"Fred","Barney","Wilma"}; } Eg: class Dummy{ public String[] dum(){ return new String[] {"fred","Barney","wilma"}; } public static void main(String args[]){ Dummy n=new Dummy(); String str[]=n.dum(); System.out.println(str[0]+" "+str[1]+" "+str[2]); }

10.  You can return any value or variable that can be implicitly converted to the declared return type Eg : public int foo(){ char c='c'; return c; // char is compatible with int } Eg: class Dummy{ public int dum(){ char c='a'; return c; } public static void main(String args[]){ Dummy n=new Dummy(); int x=n.dum(); System.out.println("x value is "+x ); } Valid only for primitive return types :

11.  You can return any value or variable that can explicitly cast to declared return type Eg : public int foo(){ float f=32.5f; return (int)f; } Eg: class Dummy{ public int dum(){ float f=32.5f; return (int)f; } public static void main(String args[]){ Dummy n=new Dummy(); int x=n.dum(); System.out.println("x value is "+x ); }

12.  If the declared return type is void, then you should not return anything Eg : public void bar(){ return " jai only "; // not legal } - However for void return type you can just say as return i.e. in above just write return; // no harm in writing that

13.  With an object reference return type, you can return any object type that can implicitly cast to the declared return type Eg : public Animal getAnimal(){ return new Horse(); //Assume Horse extends Animal } Eg: class Animal{ } class Horse extends Animal{ public Animal getAnimal(){ System.out.println("I am inside "); return new Horse(); } public static void main(String args[]){ Horse h=new Horse(); Animal animals=h.getAnimal(); }

14. More Examples : Eg (1) : public Object getObject() { int[] nums = {1,2,3}; return nums; // Return an int array, // which is still an object }

15. Eg (2) : interface Chewable{ void hello(); } class NotGum { public void bye(){ System.out.println(" bye "); } class Gum implements Chewable{ public void hello(){ System.out.println(" hello "); } public class TestChewable{ public Chewable getChewable(){ return new Gum(); } public static void main(String args[]){ TestChewable tt=new TestChewable(); Chewable ch; ch=tt.getChewable(); }

16. Eg (3) : public abstract class Animal { } public class Bear extends Animal { } public class Test { public Animal go() { return new Bear(); // OK, Bear "is-a" Animal } - This code will compile, the return value is a subtype