Date post: | 21-Dec-2015 |
Category: |
Documents |
View: | 218 times |
Download: | 1 times |
Exam Objective : Legal return Exam Objective : Legal return typestypes
PRESENTED BY :
SRINIVAS VG
Agenda :Agenda :
Return types on overloaded methods
Overriding and Return types, and Covariant returns
Returning a value
Return types on Overloaded Return types on Overloaded methods :methods : To overload a method , you
must change the argument listEg:- public class Foo{
void go(){} }
public class Bar extends Foo{String go(int x){return null;
} }
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
Return types while Overriding :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 returnclass Alpha {
Alpha dostuff(char c){return new Alpha();
}}
class Beta extends Alpha {Beta doStuff(char c){ // legal override in java 1.5return new Beta();
}}
Covariant returns :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
Till now we know :Till now we know :
Overloaded methods can
change the return types
Overridden methods cannot, except in the case of covariant returns
Returning a value : There are 6 Returning a value : There are 6 rulesrules You can return null with an object
reference return typeEg: 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); }}
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]);
}}
You can return any value or variable that can be implicitly converted to the declared return typeEg : 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 :
You can return any value or variable that can explicitly cast to declared return typeEg : 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 ); }}
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
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();
}}
More Examples :More Examples :Eg (1) : public Object getObject() { int[] nums = {1,2,3}; return nums; // Return an int array,
// which is still an object }
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(); } }
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